from menagerie.core import *
menagerie = Menagerie()
ArrayComp = menagerie.classMap[u'ArrayComp']
ArrayComp.longName = u'array computable'
CET = menagerie.classMap[u'CET']
CET.longName = u'c.e. traceable'
BB1G = menagerie.classMap[u'BB1G']
BB1G.longName = u'bounded by a 1-generic'
BB2G = menagerie.classMap[u'BB2G']
BB2G.longName = u'bounded by a 2-generic'
BB2R = menagerie.classMap[u'BB2R']
BB2R.longName = u'bounded by a 2-random'
BB3R = menagerie.classMap[u'BB3R']
BB3R.longName = u'bounded by a 3-random'
BBmin = menagerie.classMap[u'BBmin']
BBmin.longName = u'minimal or computable'
BIF = menagerie.classMap[u'BIF']
BIF.longName = u'bi-immune free'
BND1 = menagerie.classMap[u'BND1']
BND1.longName = u'bounds no density-one'
BN1G = menagerie.classMap[u'BN1G']
BN1G.longName = u'bounds no 1-generic'
BN2G = menagerie.classMap[u'BN2G']
BN2G.longName = u'bounds no 2-generic'
BN3G = menagerie.classMap[u'BN3G']
BN3G.longName = u'bounds no 3-generic'
BN1R = menagerie.classMap[u'BN1R']
BN1R.longName = u'bounds no 1-random'
BN2R = menagerie.classMap[u'BN2R']
BN2R.longName = u'bounds no 2-random'
BNDeltaTwo = menagerie.classMap[u'BNDeltaTwo']
BNDeltaTwo.longName = u'bounds no nonzero Delta_2'
BNHIF = menagerie.classMap[u'BNHIF']
BNHIF.longName = u'bounds no nonzero HIF degree'
BNLFO = menagerie.classMap[u'BNLFO']
BNLFO.longName = u'bounds no nonzero low for Omega'
BNmin = menagerie.classMap[u'BNmin']
BNmin.longName = u'bounds no minimal degree'
BNSC = menagerie.classMap[u'BNSC']
BNSC.longName = u'bounds no shift-complex'
BNW2G = menagerie.classMap[u'BNW2G']
BNW2G.longName = u'bounds no weak 2-generic'
BOGL1 = menagerie.classMap[u'BOGL1']
BOGL1.longName = u'bounds only GL_1'
BOGL2 = menagerie.classMap[u'BOGL2']
BOGL2.longName = u'bounds only GL_2'
DeltaTwo = menagerie.classMap[u'DeltaTwo']
DeltaTwo.longName = u'Delta_2'
FSI = menagerie.classMap[u'FSI']
FSI.longName = u'finite self-information'
HIF = menagerie.classMap[u'HIF']
HIF.longName = u'hyperimmune-free'
JumpTraceable = menagerie.classMap[u'JumpTraceable']
JumpTraceable.longName = u'jump traceable'
Low = menagerie.classMap[u'Low']
Low.longName = u'low'
Low1Rand = menagerie.classMap[u'Low1Rand']
Low1Rand.longName = u'low for random'
LowKurtz = menagerie.classMap[u'LowKurtz']
LowKurtz.longName = u'low for Kurtz random'
LowSchnorr = menagerie.classMap[u'LowSchnorr']
LowSchnorr.longName = u'computably traceable'
NotAboveZP = menagerie.classMap[u'NotAboveZP']
NotAboveZP.longName = u'incomplete'
NotDNC = menagerie.classMap[u'NotDNC']
NotDNC.longName = u'not DNC'
NotDNCinZP = menagerie.classMap[u'NotDNCinZP']
NotDNCinZP.longName = u"not DNC in 0'"
NotHigh = menagerie.classMap[u'NotHigh']
NotHigh.longName = u'not high'
NotPA = menagerie.classMap[u'NotPA']
NotPA.longName = u'not PA'
NotPAinZP = menagerie.classMap[u'NotPAinZP']
NotPAinZP.longName = u"not PA in 0'"
OmegaLow = menagerie.classMap[u'OmegaLow']
OmegaLow.longName = u'low for Omega'
SuperLow = menagerie.classMap[u'SuperLow']
SuperLow.longName = u'superlow'
NotAED = menagerie.classMap[u'NotAED']
NotAED.longName = u'not almost everywhere dominating'
menagerie.addImplication(ArrayComp, BOGL2, DirectJustification(u'[Downey, Jockusch and Stob 1996, Array nonrecursive degrees and genericity]'))
menagerie.addImplication(ArrayComp, BNW2G, DirectJustification(u"If $A$ is weak 2-generic, then the function mapping $n$ to the $n$th element of $A$ is not dominated by the settling-time function for $\\emptyset'$, hence $A$ is not array computable"))
menagerie.addImplication(ArrayComp, NotAED, DirectJustification(u'Every almost everywhere dominating degree is array noncomputable [Barmpalias, Tracing and domination in the Turing degrees, 2012]'))
menagerie.setProperty(CET, "pdim", 0, Unjustified())
menagerie.addImplication(CET, NotDNC, Unjustified())
menagerie.addImplication(CET, ArrayComp, DirectJustification(u'See Corollary 8.2.8 in [Nies 2009, Computability and randomness]'))
menagerie.addImplication(BB1G, NotDNC, DirectJustification(u'[Demuth and Ku\u010dera 1987, Remarks on 1-genericity, semigenericity and related concepts]'))
menagerie.addNonimplication(BB1G, NotHigh, DirectJustification(u'Friedberg jump inversion produces a high 1-generic'))
menagerie.addNonimplication(BB1G, BNmin, DirectJustification(u'There is a 1-generic bounding a minimal degree [Kumabe 1990; Chong and Downey 1990]'))
menagerie.addNonimplication(BB1G, BNDeltaTwo, DirectJustification(u'There is a $\\Delta^0_2$ 1-generic'))
menagerie.addNonimplication(BB1G, BNHIF, DirectJustification(u'Downey and Yu constructed a hyperimmune-free (minimal) degree below a 1-generic [2006, Arithmetical Sacks Forcing]'))
menagerie.addNonimplication(BB1G, BNLFO, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets] and every noncomputable c.e. set computes a 1-generic'))
menagerie.setProperty(BB2G, "category", 1, DirectJustification(u'The class of 2-generics is comeager'))
menagerie.addImplication(BB2G, BB1G, Obvious())
menagerie.addImplication(BB2G, NotHigh, DirectJustification(u"Every 2-generic $A$ satisfies $A''=A\\oplus\\emptyset''$ [Kurtz 1981, PhD thesis]. So if $A$ were high, then $A'$ would compute $A''$"))
menagerie.addImplication(BB2G, BNDeltaTwo, DirectJustification(u'Martin proved that the 2-generic degrees are downward dense below every 2-generic (see [Jockusch 1980, Degrees of generic sets]). There are no $\\Delta^0_2$ 2-generics'))
menagerie.addImplication(BB2G, BNHIF, DirectJustification(u'Martin proved that the 2-generic degrees are downward dense below every 2-generic (see [Jockusch 1980, Degrees of generic sets]). But every 2-generic (even every 1-generic) is hyperimmune'))
menagerie.addImplication(BB2G, BNmin, DirectJustification(u'Martin proved that the 2-generic degrees are downward dense below every 2-generic (see [Jockusch 1980, Degrees of generic sets]). A minimal degree clearly does not bound a 2-generic'))
menagerie.addImplication(BB2G, BNLFO, Unjustified())
menagerie.addImplication(BB2R, OmegaLow, DirectJustification(u"Every 2-random is low for $\\Omega$ by Van Lambalgen's theorem and the fact that $\\Omega\\equiv_T\\emptyset'$"))
menagerie.addImplication(BB2R, BNmin, DirectJustification(u'The 1-generics are downward dense below any 2-random [Barmpalias, Day, Lewis 2012]'))
menagerie.addImplication(BB2R, BNDeltaTwo, DirectJustification(u"Every (weak) 2-random forms a minimal pair with $\\emptyset'$"))
menagerie.addImplication(BB2R, BNSC, DirectJustification(u'No 2-random computes a shift-complex sequence [Khan]'))
menagerie.addNonimplication(BB2R, NotHigh, DirectJustification(u"$\\Omega$ relative to $\\emptyset'$ is high and 2-random"))
menagerie.setProperty(BB3R, "measure", 1, DirectJustification(u'The class of 3-randoms has measure one'))
menagerie.addImplication(BB3R, BB2R, Obvious())
menagerie.addImplication(BB3R, NotHigh, DirectJustification(u"Every 3-random $A$ satisfies $A''=A\\oplus\\emptyset''$ [Kurtz 1981, PhD thesis]. So if $A$ were high, then $A'$ would compute $A''$"))
menagerie.setProperty(BBmin, "pdim", 1, DirectJustification(u'In [Downey and Greenberg 2008, Turing degrees of reals of positive effective packing dimension], it is shown that there is an $X$ of minimal degree and effective packing dimension 1. In fact, this partially relativizes to allow $X$ to have effective packing dimension 1 relative to any given oracle. Therefore, the class of minimal degrees has (classical) packing dimension 1'))
menagerie.addImplication(BBmin, BN1R, DirectJustification(u'If $A\\oplus B$ is 1-random then $A$ and $B$ are Turing incomparable'))
menagerie.addImplication(BBmin, BN1G, DirectJustification(u'If $A\\oplus B$ is 1-generic then $A$ and $B$ are Turing incomparable'))
menagerie.addImplication(BBmin, BND1, DirectJustification(u'Every positive density point is either ML-random or computes a 1-generic [Khan, Miller 2014].'))
menagerie.addNonimplication(BBmin, NotHigh, DirectJustification(u"There is a high minimal degree by Cooper's jump inversion theorem for minimal degrees"))
menagerie.addNonimplication(BBmin, BNmin, DirectJustification(u'Consider any minimal degree'))
menagerie.addNonimplication(BBmin, BNDeltaTwo, DirectJustification(u"There is a minimal degree below $\\emptyset'$ [Sacks 1963]"))
menagerie.addNonimplication(BBmin, BNHIF, DirectJustification(u'The standard construction of a minimal degree makes it hyperimmune-free'))
menagerie.addNonimplication(BBmin, BOGL1, DirectJustification(u'[Sasso 1974, A minimal degree not realizing least possible jump]'))
menagerie.addNonimplication(BBmin, NotDNC, DirectJustification(u'[Kumabe and Lewis 2009, A fixed-point-free minimal degree]'))
menagerie.addNonimplication(BBmin, NotDNCinZP, DirectJustification(u'Given any $X$, there is a DNC relative to $X$ that is of minimal degree [Khan]'))
menagerie.addNonimplication(BBmin, BNLFO, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets], which is obviously low for $\\Omega$, and all noncomputable c.e. sets compute minimal degrees [Yates 1970, Initial segments of the degrees of unsolvability, II; Cooper 1972, Degrees of unsolvability complementary between recursively enumerable degrees]'))
menagerie.setProperty(BIF, "cardinality", 1, DirectJustification(u'The construction of bi-immune free degrees in [Jockusch 1969, The degrees of bi-immune sets] using computable perfect trees can be modified to produce continuum many such degrees'))
menagerie.setProperty(BIF, "pdim", 1, DirectJustification(u'For any $X$, there is a bi-immune free set with effective packing dimension 1 relative to $X$ [Khan]'))
menagerie.addImplication(BIF, HIF, DirectJustification(u'Every hyperimmune degree is bi-immune [Jockusch 1969]'))
menagerie.addImplication(BIF, BN1R, DirectJustification(u'Every 1-random (in fact, every Kurtz random) is bi-immune'))
menagerie.addImplication(BIF, NotDNC, DirectJustification(u'Every DNC function computes a bi-immune set [Lewis]'))
menagerie.addImplication(BIF, LowKurtz, DirectJustification(u'Every DNC function computes a bi-immune set [Lewis], as does every hyperimmune degree [Jockusch 1969, The degrees of bi-immune sets]. But low for Kurtz random is equivalent to non-DNC and hyperimmune-free [Greenberg and Miller 2009, Lowness for Kurtz randomness]'))
menagerie.addNonimplication(BIF, BBmin, DirectJustification(u'There is a pair of sets $A$ and $B$ of incomparable degree such that $A\\oplus B$ computes no bi-immune set [Jockusch 1969, The degrees of bi-immune sets]'))
menagerie.addNonimplication(BIF, BNmin, DirectJustification(u'There is a minimal bi-immune free degree [Jockusch 1969, The degrees of bi-immune sets]'))
menagerie.addNonimplication(BIF, BNHIF, DirectJustification(u'There is a nonzero bi-immune free degree and every bi-immune free degree is hyperimmune-free [Jockusch 1969, The degrees of bi-immune sets]'))
menagerie.addImplication(BND1, BN1G, DirectJustification(u'Every 1-generic is a density-one point.'))
menagerie.addImplication(BND1, BN1R, DirectJustification(u'Given any ML-random real $A \\oplus B$, either $A$ or $B$ is balanced random. Every balanced random real is a density-one point [Bienvenu, Greenberg, Ku\u010dera, Nies, Turetsky 2013].'))
menagerie.addNonimplication(BND1, BNSC, DirectJustification(u'There are arbitrarily slow-growing DNC functions that compute no Kurtz random real [Khan, Miller 2012], and hence no positive density point. On the other hand, sufficiently slow-growing DNC functions compute shift-complex sequences [Khan 2013].'))
menagerie.addImplication(BN1G, BN2G, Obvious())
menagerie.addImplication(BN1G, BN2R, DirectJustification(u'Every 2-random bounds a 1-generic [Kurtz 1981, PhD thesis]'))
menagerie.addImplication(BN1G, NotAboveZP, DirectJustification(u'There is a $\\Delta^0_2$ 1-generic'))
menagerie.addImplication(BN1G, ArrayComp, DirectJustification(u'Every array noncomputable bounds a 1-generic [Downey, Jockusch and Stob 1996, Array nonrecursive degrees and genericity]'))
menagerie.addImplication(BN1G, BNW2G, Obvious())
menagerie.addImplication(BN2G, BN3G, Obvious())
menagerie.addNonimplication(BN2G, NotAboveZP, DirectJustification(u"$\\emptyset'$ clearly bounds no 2-generic"))
menagerie.setProperty(BN3G, "category", 0, DirectJustification(u'The class of 3-generics is comeager'))
menagerie.addNonimplication(BN3G, BN2G, DirectJustification(u"$\\emptyset''$ bounds no 3-generic but does bound a 2-generic"))
menagerie.setProperty(BN1R, "hdim", 1, DirectJustification(u'In [Greenberg and Miller 2011, Diagonally non-recursive functions and effective Hausdorff dimension], it is shown that there is an $X$ of effective Hausdorff dimension 1 that computes no 1-random. In fact, this partially relativizes to allow $X$ to have effective Hausdorff dimension 1 relative to any given oracle. Therefore, the class of reals that bound no 1-random has (classical) Hausdorff dimension 1'))
menagerie.addImplication(BN1R, BN2R, Obvious())
menagerie.addImplication(BN1R, NotPA, DirectJustification(u'There is a $\\Pi^0_1$ class containing only 1-random reals, hence every PA degree computes a 1-random'))
menagerie.addNonimplication(BN1R, BNSC, DirectJustification(u'There is a shift-complex sequence that computes no 1-random [Khan]'))
menagerie.setProperty(BN2R, "measure", 0, DirectJustification(u'The class of 2-randoms has measure one'))
menagerie.addImplication(BN2R, NotPAinZP, Unjustified())
menagerie.addImplication(BNDeltaTwo, NotAboveZP, Obvious())
menagerie.addNonimplication(BNDeltaTwo, NotAED, DirectJustification(u'[]'))
menagerie.addImplication(BNHIF, NotPAinZP, Unjustified())
menagerie.setProperty(BNLFO, "hdim", 1, Unjustified())
menagerie.addImplication(BNLFO, BN2R, DirectJustification(u"Every 2-random is low for $\\Omega$ by Van Lambalgen's theorem and the fact that $\\Omega\\equiv_T\\emptyset'$"))
menagerie.addImplication(BNLFO, NotAboveZP, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets], which is obviously low for $\\Omega$'))
menagerie.addNonimplication(BNLFO, BNDeltaTwo, DirectJustification(u'Sasso, Epstein and Cooper [Sasso 1974, A minimal degree not realizing least possible jump] produced a non-low $\\Delta^0_2$ minimal degree. Obviously, this degree cannot compute a noncomputable low for $\\Omega$ (which must be GL$_1$)'))
menagerie.addImplication(BNmin, NotPA, DirectJustification(u'There is nonempty $\\Pi^0_1$ class of reals, each of which computes a minimal degree [Groszek, Slaman 1997, $\\Pi^0_1$ classes and minimal degrees]'))
menagerie.addNonimplication(BNmin, BNDeltaTwo, DirectJustification(u"Every noncomputable degree below a $\\Delta^0_2$ 1-generic contains a 1-generic [Haught 1986, The degrees below a 1-generic degree $<{\\bf 0}'$], hence is not minimal"))
menagerie.addNonimplication(BNmin, BNHIF, DirectJustification(u'Demuth proved that every noncomputable set truth-table below a 1-random is Turing equivalent to a 1-random (see [Downey and Hirschfeldt 2010, Algorithmic randomness and complexity]). Consider a hyperimmune-free 1-random $X$. Every set Turing below $X$ is truth-table below $X$. Thus every noncomputable degree below $X$ is 1-random, hence not minimal'))
menagerie.setProperty(BNSC, "measure", 1, DirectJustification(u'The measure of oracles that compute shift-complex sequences is 0 [Rumyantsev 2011]'))
menagerie.addImplication(BNSC, NotPA, DirectJustification(u'For every $\\delta\\in (0, 1)$ there is a $\\Pi^0_1$ class of $\\delta$-shift-complex sequences, nonempty by a construction of Levin. Thus every PA degree computes a shift-complex sequence'))
menagerie.addNonimplication(BNSC, BNDeltaTwo, DirectJustification(u'There is a low 1-random and a 1-random computes a shift-complex sequence iff it is complete [Khan]'))
menagerie.addImplication(BNW2G, BN2G, Obvious())
menagerie.addNonimplication(BNW2G, NotPAinZP, DirectJustification(u"By relativizing the hyperimmune-free basis theorem to $\\emptyset'$, there is a degree PA in $\\emptyset'$ such that every function it computes is dominated by a $\\emptyset'$-computable function. But every weak 2-generic $A$ computes a function that escapes every $\\emptyset'$-computable function, in particular, the function mapping $n$ to the $n$th element of $A$"))
menagerie.addImplication(BOGL1, BOGL2, Obvious())
menagerie.addImplication(BOGL1, BN2G, DirectJustification(u'Jockusch proved that every 2-generic computes a properly GL$_2$ set [1980, Degrees of generic sets]'))
menagerie.addNonimplication(BOGL1, BNW2G, DirectJustification(u"Build a partial $\\emptyset'$-computable tree as follows. Make the $n$th splits above the root $e$-splitting for every $e\\leq n$ for which this is possible. Then meet the $n$th $\\Sigma^0_1[\\emptyset']$ class on the right branch of each split. (If this is not possible, the tree stops growing above that branch.) By going right at the $n$th split if only if the $n$th $\\Sigma^0_1[\\emptyset']$ class is dense, we get a weak 2-generic path $A$. But the construction guarantees that if $B\\leq_T A$ is non-computable, then $A\\leq_T B\\oplus\\emptyset'$. Therefore, $B'\\leq_T A'\\leq_T A\\oplus\\emptyset'\\leq_T B\\oplus\\emptyset'$, so $A$ bounds only GL$_1$ degrees."))
menagerie.addImplication(BOGL2, NotAboveZP, DirectJustification(u"If $A\\geq_T\\emptyset'$, then $A''>_T A' \\equiv_T (A\\oplus\\emptyset')'$"))
menagerie.addImplication(BOGL2, BN3G, DirectJustification(u'Jockusch proved that every 3-generic computes a properly GL$_3$ set [1980, Degrees of generic sets]'))
menagerie.addNonimplication(BOGL2, BN2G, DirectJustification(u"Every 2-generic $A$ satisfies $A''=A\\oplus\\emptyset''$ [Kurtz 1981, PhD thesis]. Let $A\\leq_T\\emptyset''$ be 2-generic. Then any for any $B\\leq_T A$ we have $B''\\leq_T A''\\leq_T\\emptyset''\\leq_T (B\\oplus\\emptyset')'$"))
menagerie.setProperty(DeltaTwo, "cardinality", 0, Obvious())
menagerie.addImplication(DeltaTwo, BN2G, DirectJustification(u"No 2-generic can be computable from $\\emptyset'$"))
menagerie.addImplication(DeltaTwo, NotDNCinZP, DirectJustification(u"No function DNC relative to $\\emptyset'$ is computable from $\\emptyset'$"))
menagerie.addImplication(DeltaTwo, BNHIF, DirectJustification(u'No noncomputable $\\Delta^0_2$ degree is hyperimmune-free [W. Miller and Martin 1968, The degrees of hyperimmune sets]'))
menagerie.addImplication(DeltaTwo, BNW2G, DirectJustification(u'If $A$ is $\\Delta^0_2$, then $2^\\omega\\smallsetminus A$ is a dense $\\Sigma^0_2$ class not containing $A$'))
menagerie.addNonimplication(DeltaTwo, NotAboveZP, DirectJustification(u"$\\emptyset'$ is $\\Delta^0_2$"))
menagerie.addNonimplication(DeltaTwo, NotAED, DirectJustification(u"$0'$ is almost everywhere dominating [Dobrinen, Simpson 2004]."))
menagerie.setProperty(FSI, "cardinality", 1, DirectJustification(u'There is a perfect $\\Pi^0_1$ class of reals with finite self-information. [Herbert 2013]'))
menagerie.addImplication(FSI, JumpTraceable, DirectJustification(u'[Hirschfeldt, Weber 2012]'))
menagerie.addNonimplication(FSI, BNHIF, DirectJustification(u'There is a perfect $\\Pi^0_1$ class of reals with finite self-information [Herbert 2013]. By the hyperimmune-free basis theorem, there is a hyperimmune-free real with finite self-information.'))
menagerie.addImplication(HIF, NotDNCinZP, DirectJustification(u'This is a slight generalization of Kurtz\u2019s result that no 2-random set can be computably dominated'))
menagerie.addImplication(HIF, BN1G, DirectJustification(u'Every 1-generic is hyperimmune'))
menagerie.addImplication(HIF, NotHigh, DirectJustification(u"By Martin's theorem and the definition of hyperimmune-free"))
menagerie.addImplication(HIF, BNDeltaTwo, DirectJustification(u'No noncomputable $\\Delta^0_2$ degree is hyperimmune-free [W. Miller and Martin 1968, The degrees of hyperimmune sets]'))
menagerie.addImplication(HIF, BNLFO, DirectJustification(u'Hyperimmune-free and low for $\\Omega$ implies computable [Miller and Nies] (See [Nies 2009, Computability and Randomness])'))
menagerie.addNonimplication(HIF, NotPA, DirectJustification(u'Use the hyperimmune-free basis theorem'))
menagerie.setProperty(JumpTraceable, "cardinality", 1, DirectJustification(u'[Nies 2002, Reals which compute little]'))
menagerie.addImplication(JumpTraceable, BOGL1, DirectJustification(u'Every jump traceable is GL$_1$ [Nies 2002, Reals which compute little]'))
menagerie.addImplication(JumpTraceable, CET, DirectJustification(u'[Nies 2002, Reals which compute little]'))
menagerie.addNonimplication(JumpTraceable, BNHIF, DirectJustification(u'There is a nonempty $\\Pi^0_1$ class of jump traceable reals with no computable paths [Nies 2009, Computability and randomness]. Thus there is a noncomputable hyperimmune-free jump traceable by the hyperimmune-free basis theorem'))
menagerie.addNonimplication(JumpTraceable, NotHigh, DirectJustification(u'See Corollary 8.4.5 in [Nies 2009, Computability and randomness]'))
menagerie.addImplication(Low, DeltaTwo, Obvious())
menagerie.addImplication(Low, NotHigh, Obvious())
menagerie.addImplication(Low, BOGL1, Obvious())
menagerie.addNonimplication(Low, ArrayComp, DirectJustification(u'There is a low c.e. degree that is array noncomputable [Downey, Jockusch and Stob 1996, Array nonrecursive degrees and genericity]'))
menagerie.addImplication(Low1Rand, JumpTraceable, Unjustified())
menagerie.addImplication(Low1Rand, OmegaLow, Obvious())
menagerie.addImplication(Low1Rand, SuperLow, DirectJustification(u'[Nies 2005, Lowness properties and randomness]'))
menagerie.addImplication(Low1Rand, BNSC, DirectJustification(u'Every low for random is $K$-trivial and no $K$-trivial is shift-complex'))
menagerie.addImplication(Low1Rand, FSI, DirectJustification(u'See, for example, [Hirschfeldt, Weber 2012]'))
menagerie.addNonimplication(Low1Rand, BB1G, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets], but no 1-generic bounds a noncomputable c.e. set (see [Kumabe 1996] for the latter)'))
menagerie.addNonimplication(Low1Rand, BN1G, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets] and every noncomputable c.e. set computes a 1-generic'))
menagerie.addNonimplication(Low1Rand, BNmin, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets] and all noncomputable c.e. sets compute minimal degrees [Yates 1970, Initial segments of the degrees of unsolvability, II; Cooper 1972, Degrees of unsolvability complementary between recursively enumerable degrees]'))
menagerie.addNonimplication(Low1Rand, BNDeltaTwo, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets]'))
menagerie.addNonimplication(Low1Rand, BNLFO, DirectJustification(u'There is a noncomputable c.e. low for random [Ku\u010dera and Terwijn 1999, Lowness for the class of random sets], which is obviously low for $\\Omega$'))
menagerie.setProperty(LowKurtz, "pdim", 1, Unjustified())
menagerie.addImplication(LowKurtz, NotDNC, DirectJustification(u'[Greenberg and Miller 2009, Lowness for Kurtz randomness]'))
menagerie.addImplication(LowKurtz, HIF, DirectJustification(u'[Downey, Griffiths and Reid 2004, On Kurtz randomness]'))
menagerie.addImplication(LowKurtz, BND1, DirectJustification(u'Every density-one point is Kurtz random, hence high for Kurtz randomness.'))
menagerie.addNonimplication(LowKurtz, BIF, DirectJustification(u'Jockusch sketches a construction of a hyperimmune-free bi-immune set at the end of [1969, The degrees of bi-immune sets]. It can easily be modified to ensure the set has non-DNR degree (hence is low for Kurtz random) as well [Mushfeq]'))
menagerie.setProperty(LowSchnorr, "cardinality", 1, DirectJustification(u'There are continuum many computably traceable degrees [Terwijn and Zambella 2001, Algorithmic randomness and lowness]'))
menagerie.addImplication(LowSchnorr, LowKurtz, DirectJustification(u'Computably traceable implies hyperimmune-free and not DNC, which in turn implies being low for Kurtz (tests) [Stephan and Yu 2006, Lowness for weakly 1-generic and Kurtz-random]'))
menagerie.addImplication(LowSchnorr, CET, Obvious())
menagerie.addNonimplication(LowSchnorr, BOGL1, Unjustified())
menagerie.addNonimplication(LowSchnorr, BNmin, DirectJustification(u'The standard construction of a minimal degree makes it computably traceable'))
menagerie.addNonimplication(LowSchnorr, BBmin, DirectJustification(u'Force with pairs of computable perfect trees to produce incomparable degrees that join to a computably traceable degree'))
menagerie.addNonimplication(LowSchnorr, BNHIF, Obvious())
menagerie.addImplication(NotAboveZP, NotPAinZP, Unjustified())
menagerie.addImplication(NotDNC, NotDNCinZP, Obvious())
menagerie.addImplication(NotDNC, BN1R, DirectJustification(u'Every 1-random compute a diagonally noncomputable function [Ku\u010dera 1985, Measure, $\\Pi^0_1$ classes, and complete extensions of PA]'))
menagerie.addImplication(NotDNC, BNSC, DirectJustification(u'A shift-complex sequence $X$ is DNC as witnessed by (a finite modification of) the function $f(n) = X\\restriction n$'))
menagerie.addNonimplication(NotDNC, NotAED, DirectJustification(u'There is an incomplete c.e. set that is almost everywhere dominating [Cholak, Greenberg, Miller 2006]. An incomplete c.e. set is never DNC by the Arslanov completeness criterion.'))
menagerie.setProperty(NotDNCinZP, "hdim", 0, Unjustified())
menagerie.addImplication(NotDNCinZP, BN2R, DirectJustification(u'Relativize the fact [Ku\u010dera 1985, Measure, $\\Pi^0_1$ classes, and complete extensions of PA] that every 1-random computes a diagonally noncomputable function'))
menagerie.addImplication(NotHigh, NotAboveZP, Obvious())
menagerie.addImplication(NotHigh, NotAED, Obvious())
menagerie.addImplication(NotPA, NotAboveZP, DirectJustification(u"$\\emptyset'$ has PA degree"))
menagerie.addNonimplication(NotPAinZP, NotAboveZP, Unjustified())
menagerie.addNonimplication(NotPAinZP, BN2R, Unjustified())
menagerie.addImplication(OmegaLow, NotAboveZP, DirectJustification(u"$\\Omega\\leq_T\\emptyset'$, hence not random relative to $\\emptyset'$"))
menagerie.addImplication(OmegaLow, ArrayComp, Unjustified())
menagerie.addImplication(OmegaLow, BOGL1, DirectJustification(u'Theorem 3.2 in [Nies, Stephan and Terwijn 2005, Randomness, relativization and Turing degrees]. See also Proposition 3.4.10 in [Nies 2009, Computability and Randomness]'))
menagerie.addImplication(OmegaLow, BNHIF, DirectJustification(u'Hyperimmune-free and low for $\\Omega$ implies computable [Miller and Nies] (See [Nies 2009, Computability and Randomness])'))
menagerie.addNonimplication(OmegaLow, NotPA, DirectJustification(u'Use the low for $\\Omega$ basis theorem [Downey, Hirschfeldt, Miller and Nies 2005; Reimann and Slaman, Measures and their random reals]'))
menagerie.addImplication(SuperLow, Low, Obvious())
menagerie.addImplication(SuperLow, ArrayComp, DirectJustification(u'[Nies and Ng] (see Exercise 8.2.10 in [Nies 2009, Computability and Randomness]'))
menagerie.addNonimplication(SuperLow, OmegaLow, DirectJustification(u"There is a superlow 1-random $X$ by the (super)low basis theorem. Note that $X\\leq_T\\Omega\\equiv_T\\emptyset'$, so if $X$ were low for $\\Omega$, then it would be a base for 1-randomness. Then by [Hirschfeldt, Nies and Stephan 2007, Using random sets as oracles], $X$ would be low for random. But a 1-random cannot be low for random"))
menagerie.addNonimplication(SuperLow, NotPA, DirectJustification(u'Use the (super)low basis theorem'))
menagerie.addImplication(NotAED, NotAboveZP, DirectJustification(u"$0'$ is almost everywhere dominating [Dobrinen, Simpson 2004]."))
menagerie.setProperty(CET, "category", 0, CET.pdim)
menagerie.setProperty(CET, "hdim", 0, CET.pdim)
menagerie.setProperty(CET, "measure", 0, CET.pdim)
menagerie.setProperty(BB2G, "cardinality", 1, BB2G.category)
menagerie.setProperty(BB2G, "pdim", 1, BB2G.category)
menagerie.setProperty(BB3R, "cardinality", 1, BB3R.measure)
menagerie.setProperty(BB3R, "hdim", 1, BB3R.measure)
menagerie.setProperty(BB3R, "pdim", 1, BB3R.measure)
menagerie.setProperty(BBmin, "cardinality", 1, BBmin.pdim)
menagerie.setProperty(BN1R, "cardinality", 1, BN1R.hdim)
menagerie.setProperty(BN1R, "pdim", 1, BN1R.hdim)
menagerie.setProperty(BNLFO, "cardinality", 1, BNLFO.hdim)
menagerie.setProperty(BNLFO, "pdim", 1, BNLFO.hdim)
menagerie.setProperty(BNSC, "cardinality", 1, BNSC.measure)
menagerie.setProperty(BNSC, "hdim", 1, BNSC.measure)
menagerie.setProperty(BNSC, "pdim", 1, BNSC.measure)
menagerie.setProperty(DeltaTwo, "category", 0, DeltaTwo.cardinality)
menagerie.setProperty(DeltaTwo, "hdim", 0, DeltaTwo.cardinality)
menagerie.setProperty(DeltaTwo, "pdim", 0, DeltaTwo.cardinality)
menagerie.setProperty(DeltaTwo, "measure", 0, DeltaTwo.cardinality)
menagerie.setProperty(LowKurtz, "cardinality", 1, LowKurtz.pdim)
menagerie.setProperty(NotDNCinZP, "measure", 0, NotDNCinZP.hdim)
menagerie.addImplication(ArrayComp, BN2G, CompositeJustification(ArrayComp.implies(BNW2G), BNW2G.implies(BN2G)))
menagerie.addImplication(ArrayComp, BN3G, CompositeJustification(ArrayComp.implies(BOGL2), BOGL2.implies(BN3G)))
menagerie.addImplication(ArrayComp, NotAboveZP, CompositeJustification(ArrayComp.implies(BOGL2), BOGL2.implies(NotAboveZP)))
menagerie.addNonimplication(ArrayComp, OmegaLow, CompositeJustification(SuperLow.implies(ArrayComp), SuperLow.doesNotImply(OmegaLow)))
menagerie.addNonimplication(ArrayComp, NotPA, CompositeJustification(OmegaLow.implies(ArrayComp), OmegaLow.doesNotImply(NotPA)))
menagerie.setProperty(CET, "cardinality", 1, CompositeJustification(JumpTraceable.cardinality, JumpTraceable.implies(CET)))
menagerie.addImplication(CET, BNW2G, CompositeJustification(CET.implies(ArrayComp), ArrayComp.implies(BNW2G)))
menagerie.addImplication(CET, BOGL2, CompositeJustification(CET.implies(ArrayComp), ArrayComp.implies(BOGL2)))
menagerie.addImplication(CET, NotAED, CompositeJustification(CET.implies(ArrayComp), ArrayComp.implies(NotAED)))
menagerie.addImplication(CET, BN1R, CompositeJustification(CET.implies(NotDNC), NotDNC.implies(BN1R)))
menagerie.addImplication(CET, BNSC, CompositeJustification(CET.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addImplication(CET, NotDNCinZP, CompositeJustification(CET.implies(NotDNC), NotDNC.implies(NotDNCinZP)))
menagerie.addNonimplication(CET, BNHIF, CompositeJustification(JumpTraceable.implies(CET), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(CET, NotHigh, CompositeJustification(JumpTraceable.implies(CET), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(CET, BBmin, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(BBmin)))
menagerie.addNonimplication(CET, BNmin, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(BNmin)))
menagerie.addNonimplication(CET, BOGL1, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(BOGL1)))
menagerie.setProperty(BB1G, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BB1G)))
menagerie.addImplication(BB1G, BN1R, CompositeJustification(BB1G.implies(NotDNC), NotDNC.implies(BN1R)))
menagerie.addImplication(BB1G, BNSC, CompositeJustification(BB1G.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addImplication(BB1G, NotDNCinZP, CompositeJustification(BB1G.implies(NotDNC), NotDNC.implies(NotDNCinZP)))
menagerie.addNonimplication(BB1G, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BB1G, BB3R, CompositeJustification(BB3R.implies(NotHigh), BB1G.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB1G, DeltaTwo, CompositeJustification(DeltaTwo.implies(BNHIF), BB1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(BB1G, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BB1G, Low, CompositeJustification(Low.implies(NotHigh), BB1G.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB1G, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BB1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(BB1G, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addImplication(BB2G, NotDNC, CompositeJustification(BB2G.implies(BB1G), BB1G.implies(NotDNC)))
menagerie.addImplication(BB2G, NotAboveZP, CompositeJustification(BB2G.implies(BNDeltaTwo), BNDeltaTwo.implies(NotAboveZP)))
menagerie.addImplication(BB2G, NotPAinZP, CompositeJustification(BB2G.implies(BNHIF), BNHIF.implies(NotPAinZP)))
menagerie.addImplication(BB2G, BN2R, CompositeJustification(BB2G.implies(BNLFO), BNLFO.implies(BN2R)))
menagerie.addImplication(BB2G, NotPA, CompositeJustification(BB2G.implies(BNmin), BNmin.implies(NotPA)))
menagerie.addImplication(BB2G, NotAED, CompositeJustification(BB2G.implies(NotHigh), NotHigh.implies(NotAED)))
menagerie.addNonimplication(BB2G, BN3G, CompositeJustification(BB2G.category, BN3G.category))
menagerie.setProperty(BB2R, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BB2R)))
menagerie.addImplication(BB2R, NotAboveZP, CompositeJustification(BB2R.implies(BNDeltaTwo), BNDeltaTwo.implies(NotAboveZP)))
menagerie.addImplication(BB2R, NotPA, CompositeJustification(BB2R.implies(BNmin), BNmin.implies(NotPA)))
menagerie.addImplication(BB2R, ArrayComp, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(ArrayComp)))
menagerie.addImplication(BB2R, BNHIF, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(BNHIF)))
menagerie.addImplication(BB2R, BOGL1, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(BOGL1)))
menagerie.addNonimplication(BB2R, BB2G, CompositeJustification(BB2G.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB2R, HIF, CompositeJustification(HIF.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB2R, Low, CompositeJustification(Low.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB2R, BB3R, CompositeJustification(BB3R.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addImplication(BB3R, BNDeltaTwo, CompositeJustification(BB3R.implies(BB2R), BB2R.implies(BNDeltaTwo)))
menagerie.addImplication(BB3R, BNmin, CompositeJustification(BB3R.implies(BB2R), BB2R.implies(BNmin)))
menagerie.addImplication(BB3R, BNSC, CompositeJustification(BB3R.implies(BB2R), BB2R.implies(BNSC)))
menagerie.addImplication(BB3R, OmegaLow, CompositeJustification(BB3R.implies(BB2R), BB2R.implies(OmegaLow)))
menagerie.addImplication(BB3R, NotAboveZP, CompositeJustification(BB3R.implies(NotHigh), NotHigh.implies(NotAboveZP)))
menagerie.addImplication(BB3R, NotAED, CompositeJustification(BB3R.implies(NotHigh), NotHigh.implies(NotAED)))
menagerie.addNonimplication(BB3R, BN2R, CompositeJustification(BB3R.measure, BN2R.measure))
menagerie.addImplication(BBmin, ArrayComp, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(ArrayComp)))
menagerie.addImplication(BBmin, BN2G, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(BN2G)))
menagerie.addImplication(BBmin, BN2R, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(BN2R)))
menagerie.addImplication(BBmin, BNW2G, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(BNW2G)))
menagerie.addImplication(BBmin, NotAboveZP, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(NotAboveZP)))
menagerie.addImplication(BBmin, NotPA, CompositeJustification(BBmin.implies(BN1R), BN1R.implies(NotPA)))
menagerie.addNonimplication(BBmin, CET, CompositeJustification(BBmin.pdim, CET.pdim))
menagerie.addNonimplication(BBmin, DeltaTwo, CompositeJustification(DeltaTwo.implies(BNHIF), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BBmin, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BBmin, Low, CompositeJustification(Low.implies(BOGL1), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BBmin, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BBmin, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BBmin, BB3R, CompositeJustification(BB3R.implies(NotHigh), BBmin.doesNotImply(NotHigh)))
menagerie.addNonimplication(BBmin, BIF, CompositeJustification(BIF.implies(NotDNC), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BBmin, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BBmin, LowKurtz, CompositeJustification(LowKurtz.implies(NotDNC), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BBmin, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BBmin, BB1G, CompositeJustification(BB1G.implies(NotDNC), BBmin.doesNotImply(NotDNC)))
menagerie.addImplication(BIF, BN2R, CompositeJustification(BIF.implies(BN1R), BN1R.implies(BN2R)))
menagerie.addImplication(BIF, NotPA, CompositeJustification(BIF.implies(BN1R), BN1R.implies(NotPA)))
menagerie.addImplication(BIF, BN1G, CompositeJustification(BIF.implies(HIF), HIF.implies(BN1G)))
menagerie.addImplication(BIF, BNDeltaTwo, CompositeJustification(BIF.implies(HIF), HIF.implies(BNDeltaTwo)))
menagerie.addImplication(BIF, BNLFO, CompositeJustification(BIF.implies(HIF), HIF.implies(BNLFO)))
menagerie.addImplication(BIF, NotDNCinZP, CompositeJustification(BIF.implies(HIF), HIF.implies(NotDNCinZP)))
menagerie.addImplication(BIF, NotHigh, CompositeJustification(BIF.implies(HIF), HIF.implies(NotHigh)))
menagerie.addImplication(BIF, BND1, CompositeJustification(BIF.implies(LowKurtz), LowKurtz.implies(BND1)))
menagerie.addImplication(BIF, BNSC, CompositeJustification(BIF.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addNonimplication(BIF, CET, CompositeJustification(BIF.pdim, CET.pdim))
menagerie.addNonimplication(BIF, DeltaTwo, CompositeJustification(BIF.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(BIF, BB2G, CompositeJustification(BB2G.implies(BNHIF), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(BIF, BB2R, CompositeJustification(BB2R.implies(BNmin), BIF.doesNotImply(BNmin)))
menagerie.addNonimplication(BIF, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BIF.doesNotImply(BNHIF)))
menagerie.setProperty(BND1, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(BND1)))
menagerie.addImplication(BND1, ArrayComp, CompositeJustification(BND1.implies(BN1G), BN1G.implies(ArrayComp)))
menagerie.addImplication(BND1, BN2G, CompositeJustification(BND1.implies(BN1G), BN1G.implies(BN2G)))
menagerie.addImplication(BND1, BN2R, CompositeJustification(BND1.implies(BN1G), BN1G.implies(BN2R)))
menagerie.addImplication(BND1, BNW2G, CompositeJustification(BND1.implies(BN1G), BN1G.implies(BNW2G)))
menagerie.addImplication(BND1, NotAboveZP, CompositeJustification(BND1.implies(BN1G), BN1G.implies(NotAboveZP)))
menagerie.addImplication(BND1, NotPA, CompositeJustification(BND1.implies(BN1R), BN1R.implies(NotPA)))
menagerie.addNonimplication(BND1, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BND1, BNDeltaTwo, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BND1, BNHIF, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BND1, BNLFO, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(BND1, BNmin, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BND1, BOGL1, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BND1, NotDNC, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BND1, NotDNCinZP, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(BND1, NotHigh, CompositeJustification(BBmin.implies(BND1), BBmin.doesNotImply(NotHigh)))
menagerie.addNonimplication(BND1, BB2R, CompositeJustification(BB2R.implies(BNSC), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BND1, BIF, CompositeJustification(LowKurtz.implies(BND1), LowKurtz.doesNotImply(BIF)))
menagerie.setProperty(BN1G, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(BN1G)))
menagerie.setProperty(BN1G, "measure", 0, CompositeJustification(BN2R.measure, BN1G.implies(BN2R)))
menagerie.addImplication(BN1G, BOGL2, CompositeJustification(BN1G.implies(ArrayComp), ArrayComp.implies(BOGL2)))
menagerie.addImplication(BN1G, NotAED, CompositeJustification(BN1G.implies(ArrayComp), ArrayComp.implies(NotAED)))
menagerie.addImplication(BN1G, BN3G, CompositeJustification(BN1G.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(BN1G, NotPAinZP, CompositeJustification(BN1G.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(BN1G, BNDeltaTwo, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN1G, BNHIF, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN1G, BNLFO, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(BN1G, BNmin, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BN1G, BOGL1, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1G, NotDNC, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN1G, NotDNCinZP, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(BN1G, NotHigh, CompositeJustification(BBmin.implies(BN1G), BBmin.doesNotImply(NotHigh)))
menagerie.addNonimplication(BN1G, BNSC, CompositeJustification(BND1.implies(BN1G), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1G, NotPA, CompositeJustification(HIF.implies(BN1G), HIF.doesNotImply(NotPA)))
menagerie.setProperty(BN2G, "category", 0, CompositeJustification(BN3G.category, BN2G.implies(BN3G)))
menagerie.addNonimplication(BN2G, BN1G, CompositeJustification(BN1G.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BNLFO, CompositeJustification(BNLFO.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, NotHigh, CompositeJustification(NotHigh.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BNDeltaTwo, CompositeJustification(BNDeltaTwo.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, OmegaLow, CompositeJustification(OmegaLow.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, NotPAinZP, CompositeJustification(BNW2G.implies(BN2G), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BN2G, BNW2G, CompositeJustification(BOGL1.implies(BN2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BN2G, NotAED, CompositeJustification(DeltaTwo.implies(BN2G), DeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BN2G, NotPA, CompositeJustification(NotPA.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, BN1G, CompositeJustification(BN1G.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, DeltaTwo, CompositeJustification(DeltaTwo.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BOGL1, CompositeJustification(BOGL1.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BNW2G, CompositeJustification(BNW2G.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, NotAboveZP, CompositeJustification(BN2G.implies(BN3G), BN2G.doesNotImply(NotAboveZP)))
menagerie.setProperty(BN1R, "measure", 0, CompositeJustification(BN2R.measure, BN1R.implies(BN2R)))
menagerie.addImplication(BN1R, NotPAinZP, CompositeJustification(BN1R.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addImplication(BN1R, NotAboveZP, CompositeJustification(BN1R.implies(NotPA), NotPA.implies(NotAboveZP)))
menagerie.addNonimplication(BN1R, BB2R, CompositeJustification(BB2R.implies(BNSC), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1R, BBmin, CompositeJustification(BIF.implies(BN1R), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BN1R, BOGL1, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1R, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1R, NotDNC, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN1R, NotDNCinZP, CompositeJustification(BN1R.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(BN1R, BNDeltaTwo, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN1R, BNHIF, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN1R, BNLFO, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(BN1R, BNmin, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BN1R, NotHigh, CompositeJustification(BBmin.implies(BN1R), BBmin.doesNotImply(NotHigh)))
menagerie.addNonimplication(BN1R, NotAED, CompositeJustification(NotDNC.implies(BN1R), NotDNC.doesNotImply(NotAED)))
menagerie.setProperty(BN2R, "hdim", 1, CompositeJustification(BN1R.hdim, BN1R.implies(BN2R)))
menagerie.addNonimplication(BN2R, BNDeltaTwo, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN2R, BNSC, CompositeJustification(BN1R.implies(BN2R), BN1R.doesNotImply(BNSC)))
menagerie.setProperty(BNDeltaTwo, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BNDeltaTwo)))
menagerie.addImplication(BNDeltaTwo, NotPAinZP, CompositeJustification(BNDeltaTwo.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(BNDeltaTwo, ArrayComp, CompositeJustification(ArrayComp.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, NotHigh, CompositeJustification(BB2R.implies(BNDeltaTwo), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNDeltaTwo, NotPA, CompositeJustification(HIF.implies(BNDeltaTwo), HIF.doesNotImply(NotPA)))
menagerie.setProperty(BNHIF, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BNHIF)))
menagerie.addNonimplication(BNHIF, NotAboveZP, CompositeJustification(DeltaTwo.implies(BNHIF), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, NotAED, CompositeJustification(DeltaTwo.implies(BNHIF), DeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNHIF, NotPA, CompositeJustification(OmegaLow.implies(BNHIF), OmegaLow.doesNotImply(NotPA)))
menagerie.setProperty(BNLFO, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BNLFO)))
menagerie.setProperty(BNLFO, "measure", 0, CompositeJustification(BN2R.measure, BNLFO.implies(BN2R)))
menagerie.addImplication(BNLFO, NotPAinZP, CompositeJustification(BNLFO.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(BNLFO, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNLFO, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNLFO, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNLFO, NotDNCinZP, CompositeJustification(BNLFO.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(BNLFO, NotPA, CompositeJustification(HIF.implies(BNLFO), HIF.doesNotImply(NotPA)))
menagerie.setProperty(BNmin, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BNmin)))
menagerie.addImplication(BNmin, NotAboveZP, CompositeJustification(BNmin.implies(NotPA), NotPA.implies(NotAboveZP)))
menagerie.addNonimplication(BNmin, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNmin, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNmin, DeltaTwo, CompositeJustification(DeltaTwo.implies(BNHIF), BNmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNmin, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNmin, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BNmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNmin, NotHigh, CompositeJustification(BB2R.implies(BNmin), BB2R.doesNotImply(NotHigh)))
menagerie.addImplication(BNSC, NotAboveZP, CompositeJustification(BNSC.implies(NotPA), NotPA.implies(NotAboveZP)))
menagerie.addNonimplication(BNSC, BB1G, CompositeJustification(Low1Rand.implies(BNSC), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BNSC, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BNSC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNSC, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BNSC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNSC, BN1G, CompositeJustification(Low1Rand.implies(BNSC), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(BNSC, BN2R, CompositeJustification(BNSC.measure, BN2R.measure))
menagerie.addNonimplication(BNSC, BNLFO, CompositeJustification(Low1Rand.implies(BNSC), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(BNSC, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BNSC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNSC, BNmin, CompositeJustification(Low1Rand.implies(BNSC), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(BNSC, NotHigh, CompositeJustification(BB2R.implies(BNSC), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNSC, NotAED, CompositeJustification(NotDNC.implies(BNSC), NotDNC.doesNotImply(NotAED)))
menagerie.addImplication(BNW2G, BN3G, CompositeJustification(BNW2G.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addNonimplication(BNW2G, BN2R, CompositeJustification(BN2R.implies(NotPAinZP), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BNW2G, BNHIF, CompositeJustification(BNHIF.implies(NotPAinZP), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BNW2G, NotAboveZP, CompositeJustification(DeltaTwo.implies(BNW2G), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNW2G, NotAED, CompositeJustification(DeltaTwo.implies(BNW2G), DeltaTwo.doesNotImply(NotAED)))
menagerie.setProperty(BOGL1, "cardinality", 1, CompositeJustification(JumpTraceable.cardinality, JumpTraceable.implies(BOGL1)))
menagerie.addImplication(BOGL1, BN3G, CompositeJustification(BOGL1.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(BOGL1, NotAboveZP, CompositeJustification(BOGL1.implies(BOGL2), BOGL2.implies(NotAboveZP)))
menagerie.addNonimplication(BOGL1, BN1G, CompositeJustification(BN1G.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, DeltaTwo, CompositeJustification(DeltaTwo.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, NotHigh, CompositeJustification(JumpTraceable.implies(BOGL1), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(BOGL1, ArrayComp, CompositeJustification(ArrayComp.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, BNHIF, CompositeJustification(JumpTraceable.implies(BOGL1), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(BOGL1, NotPA, CompositeJustification(OmegaLow.implies(BOGL1), OmegaLow.doesNotImply(NotPA)))
menagerie.setProperty(BOGL2, "category", 0, CompositeJustification(BN3G.category, BOGL2.implies(BN3G)))
menagerie.addImplication(BOGL2, NotPAinZP, CompositeJustification(BOGL2.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(BOGL2, BN1G, CompositeJustification(BN1G.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, DeltaTwo, CompositeJustification(DeltaTwo.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BOGL1, CompositeJustification(BOGL1.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BNW2G, CompositeJustification(BNW2G.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addImplication(DeltaTwo, BN3G, CompositeJustification(DeltaTwo.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(DeltaTwo, NotPAinZP, CompositeJustification(DeltaTwo.implies(BNHIF), BNHIF.implies(NotPAinZP)))
menagerie.addImplication(DeltaTwo, BN2R, CompositeJustification(DeltaTwo.implies(NotDNCinZP), NotDNCinZP.implies(BN2R)))
menagerie.addNonimplication(DeltaTwo, ArrayComp, CompositeJustification(Low.implies(DeltaTwo), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(DeltaTwo, BN1G, CompositeJustification(BN1G.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, OmegaLow, CompositeJustification(OmegaLow.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BNDeltaTwo, CompositeJustification(BNDeltaTwo.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BNLFO, CompositeJustification(BNLFO.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, NotHigh, CompositeJustification(NotHigh.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, NotPA, CompositeJustification(NotPA.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addImplication(FSI, CET, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(CET)))
menagerie.addImplication(FSI, BOGL1, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(BOGL1)))
menagerie.addNonimplication(FSI, DeltaTwo, CompositeJustification(FSI.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(FSI, BB2G, CompositeJustification(BB2G.implies(BNHIF), FSI.doesNotImply(BNHIF)))
menagerie.addNonimplication(FSI, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), FSI.doesNotImply(BNHIF)))
menagerie.addNonimplication(FSI, BB1G, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(FSI, BN1G, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(FSI, BNDeltaTwo, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(FSI, BNLFO, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(FSI, BNmin, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BNmin)))
menagerie.setProperty(HIF, "cardinality", 1, CompositeJustification(BIF.cardinality, BIF.implies(HIF)))
menagerie.setProperty(HIF, "hdim", 0, CompositeJustification(NotDNCinZP.hdim, HIF.implies(NotDNCinZP)))
menagerie.setProperty(HIF, "pdim", 1, CompositeJustification(BIF.pdim, BIF.implies(HIF)))
menagerie.addImplication(HIF, ArrayComp, CompositeJustification(HIF.implies(BN1G), BN1G.implies(ArrayComp)))
menagerie.addImplication(HIF, BN2G, CompositeJustification(HIF.implies(BN1G), BN1G.implies(BN2G)))
menagerie.addImplication(HIF, BN2R, CompositeJustification(HIF.implies(BN1G), BN1G.implies(BN2R)))
menagerie.addImplication(HIF, BNW2G, CompositeJustification(HIF.implies(BN1G), BN1G.implies(BNW2G)))
menagerie.addImplication(HIF, NotAboveZP, CompositeJustification(HIF.implies(BN1G), BN1G.implies(NotAboveZP)))
menagerie.addImplication(HIF, NotAED, CompositeJustification(HIF.implies(NotHigh), NotHigh.implies(NotAED)))
menagerie.addNonimplication(HIF, BBmin, CompositeJustification(BIF.implies(HIF), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(HIF, BNHIF, CompositeJustification(BIF.implies(HIF), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(HIF, BNmin, CompositeJustification(BIF.implies(HIF), BIF.doesNotImply(BNmin)))
menagerie.addNonimplication(HIF, BIF, CompositeJustification(LowKurtz.implies(HIF), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(HIF, BN1R, CompositeJustification(BN1R.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.addNonimplication(HIF, BNSC, CompositeJustification(BNSC.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.setProperty(JumpTraceable, "pdim", 0, CompositeJustification(CET.pdim, JumpTraceable.implies(CET)))
menagerie.addImplication(JumpTraceable, ArrayComp, CompositeJustification(JumpTraceable.implies(CET), CET.implies(ArrayComp)))
menagerie.addImplication(JumpTraceable, BOGL2, CompositeJustification(JumpTraceable.implies(BOGL1), BOGL1.implies(BOGL2)))
menagerie.addImplication(JumpTraceable, NotDNC, CompositeJustification(JumpTraceable.implies(CET), CET.implies(NotDNC)))
menagerie.addImplication(JumpTraceable, BN2G, CompositeJustification(JumpTraceable.implies(BOGL1), BOGL1.implies(BN2G)))
menagerie.addNonimplication(JumpTraceable, DeltaTwo, CompositeJustification(JumpTraceable.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(JumpTraceable, Low, CompositeJustification(Low.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(JumpTraceable, BB2G, CompositeJustification(BB2G.implies(BNHIF), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(JumpTraceable, BB3R, CompositeJustification(BB3R.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(JumpTraceable, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(JumpTraceable, BB1G, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(JumpTraceable, BN1G, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(JumpTraceable, BNDeltaTwo, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(JumpTraceable, BNLFO, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(JumpTraceable, BNmin, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(JumpTraceable, HIF, CompositeJustification(HIF.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.setProperty(Low, "cardinality", 0, CompositeJustification(DeltaTwo.cardinality, Low.implies(DeltaTwo)))
menagerie.addImplication(Low, BN2G, CompositeJustification(Low.implies(BOGL1), BOGL1.implies(BN2G)))
menagerie.addImplication(Low, BOGL2, CompositeJustification(Low.implies(BOGL1), BOGL1.implies(BOGL2)))
menagerie.addImplication(Low, NotAboveZP, CompositeJustification(Low.implies(NotHigh), NotHigh.implies(NotAboveZP)))
menagerie.addImplication(Low, BNHIF, CompositeJustification(Low.implies(DeltaTwo), DeltaTwo.implies(BNHIF)))
menagerie.addImplication(Low, BNW2G, CompositeJustification(Low.implies(DeltaTwo), DeltaTwo.implies(BNW2G)))
menagerie.addImplication(Low, NotDNCinZP, CompositeJustification(Low.implies(DeltaTwo), DeltaTwo.implies(NotDNCinZP)))
menagerie.addImplication(Low, NotAED, CompositeJustification(Low.implies(NotHigh), NotHigh.implies(NotAED)))
menagerie.addNonimplication(Low, CET, CompositeJustification(CET.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, BN1G, CompositeJustification(BN1G.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, OmegaLow, CompositeJustification(OmegaLow.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, SuperLow, CompositeJustification(SuperLow.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, NotPA, CompositeJustification(SuperLow.implies(Low), SuperLow.doesNotImply(NotPA)))
menagerie.addImplication(Low1Rand, NotPA, CompositeJustification(Low1Rand.implies(BNSC), BNSC.implies(NotPA)))
menagerie.addImplication(Low1Rand, ArrayComp, CompositeJustification(Low1Rand.implies(OmegaLow), OmegaLow.implies(ArrayComp)))
menagerie.addImplication(Low1Rand, CET, CompositeJustification(Low1Rand.implies(JumpTraceable), JumpTraceable.implies(CET)))
menagerie.addImplication(Low1Rand, BOGL1, CompositeJustification(Low1Rand.implies(JumpTraceable), JumpTraceable.implies(BOGL1)))
menagerie.addImplication(Low1Rand, NotAboveZP, CompositeJustification(Low1Rand.implies(OmegaLow), OmegaLow.implies(NotAboveZP)))
menagerie.addImplication(Low1Rand, BNHIF, CompositeJustification(Low1Rand.implies(OmegaLow), OmegaLow.implies(BNHIF)))
menagerie.addImplication(Low1Rand, Low, CompositeJustification(Low1Rand.implies(SuperLow), SuperLow.implies(Low)))
menagerie.addNonimplication(Low1Rand, BB2G, CompositeJustification(BB2G.implies(BB1G), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(Low1Rand, BBmin, CompositeJustification(BBmin.implies(BN1G), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(Low1Rand, BND1, CompositeJustification(BND1.implies(BN1G), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(Low1Rand, HIF, CompositeJustification(HIF.implies(BN1G), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(Low1Rand, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addImplication(LowKurtz, BN1G, CompositeJustification(LowKurtz.implies(BND1), BND1.implies(BN1G)))
menagerie.addImplication(LowKurtz, BN1R, CompositeJustification(LowKurtz.implies(BND1), BND1.implies(BN1R)))
menagerie.addImplication(LowKurtz, BNDeltaTwo, CompositeJustification(LowKurtz.implies(HIF), HIF.implies(BNDeltaTwo)))
menagerie.addImplication(LowKurtz, BNLFO, CompositeJustification(LowKurtz.implies(HIF), HIF.implies(BNLFO)))
menagerie.addImplication(LowKurtz, NotDNCinZP, CompositeJustification(LowKurtz.implies(HIF), HIF.implies(NotDNCinZP)))
menagerie.addImplication(LowKurtz, NotHigh, CompositeJustification(LowKurtz.implies(HIF), HIF.implies(NotHigh)))
menagerie.addImplication(LowKurtz, BNSC, CompositeJustification(LowKurtz.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addNonimplication(LowKurtz, CET, CompositeJustification(LowKurtz.pdim, CET.pdim))
menagerie.addNonimplication(LowKurtz, BBmin, CompositeJustification(BIF.implies(LowKurtz), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(LowKurtz, BNHIF, CompositeJustification(BIF.implies(LowKurtz), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(LowKurtz, BNmin, CompositeJustification(BIF.implies(LowKurtz), BIF.doesNotImply(BNmin)))
menagerie.addNonimplication(LowKurtz, BOGL1, CompositeJustification(LowSchnorr.implies(LowKurtz), LowSchnorr.doesNotImply(BOGL1)))
menagerie.setProperty(LowSchnorr, "pdim", 0, CompositeJustification(CET.pdim, LowSchnorr.implies(CET)))
menagerie.addImplication(LowSchnorr, ArrayComp, CompositeJustification(LowSchnorr.implies(CET), CET.implies(ArrayComp)))
menagerie.addImplication(LowSchnorr, NotDNC, CompositeJustification(LowSchnorr.implies(CET), CET.implies(NotDNC)))
menagerie.addImplication(LowSchnorr, BND1, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(BND1)))
menagerie.addImplication(LowSchnorr, HIF, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(HIF)))
menagerie.addNonimplication(LowSchnorr, DeltaTwo, CompositeJustification(LowSchnorr.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(LowSchnorr, Low, CompositeJustification(Low.implies(BOGL1), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(LowSchnorr, BB2G, CompositeJustification(BB2G.implies(BNHIF), LowSchnorr.doesNotImply(BNHIF)))
menagerie.addNonimplication(LowSchnorr, BB2R, CompositeJustification(BB2R.implies(BNmin), LowSchnorr.doesNotImply(BNmin)))
menagerie.addNonimplication(LowSchnorr, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), LowSchnorr.doesNotImply(BNHIF)))
menagerie.addNonimplication(LowSchnorr, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), LowSchnorr.doesNotImply(BOGL1)))
menagerie.setProperty(NotAboveZP, "hdim", 1, CompositeJustification(BNLFO.hdim, BNLFO.implies(NotAboveZP)))
menagerie.addNonimplication(NotAboveZP, BN2G, CompositeJustification(BOGL2.implies(NotAboveZP), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(NotAboveZP, BNDeltaTwo, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotAboveZP, NotAED, CompositeJustification(BNDeltaTwo.implies(NotAboveZP), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(NotAboveZP, NotPA, CompositeJustification(OmegaLow.implies(NotAboveZP), OmegaLow.doesNotImply(NotPA)))
menagerie.setProperty(NotDNC, "cardinality", 1, CompositeJustification(BIF.cardinality, BIF.implies(NotDNC)))
menagerie.setProperty(NotDNC, "hdim", 0, CompositeJustification(NotDNCinZP.hdim, NotDNC.implies(NotDNCinZP)))
menagerie.setProperty(NotDNC, "pdim", 1, CompositeJustification(BIF.pdim, BIF.implies(NotDNC)))
menagerie.addImplication(NotDNC, BN2R, CompositeJustification(NotDNC.implies(BN1R), BN1R.implies(BN2R)))
menagerie.addImplication(NotDNC, NotPA, CompositeJustification(NotDNC.implies(BN1R), BN1R.implies(NotPA)))
menagerie.addNonimplication(NotDNC, ArrayComp, CompositeJustification(ArrayComp.implies(NotAED), NotDNC.doesNotImply(NotAED)))
menagerie.addNonimplication(NotDNC, BBmin, CompositeJustification(BIF.implies(NotDNC), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(NotDNC, BIF, CompositeJustification(LowKurtz.implies(NotDNC), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(NotDNC, BNDeltaTwo, CompositeJustification(BB1G.implies(NotDNC), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNC, BNHIF, CompositeJustification(BB1G.implies(NotDNC), BB1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotDNC, BNLFO, CompositeJustification(BB1G.implies(NotDNC), BB1G.doesNotImply(BNLFO)))
menagerie.addNonimplication(NotDNC, BNmin, CompositeJustification(BB1G.implies(NotDNC), BB1G.doesNotImply(BNmin)))
menagerie.addNonimplication(NotDNC, NotHigh, CompositeJustification(BB1G.implies(NotDNC), BB1G.doesNotImply(NotHigh)))
menagerie.addImplication(NotDNCinZP, NotPAinZP, CompositeJustification(NotDNCinZP.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(NotDNCinZP, NotAboveZP, CompositeJustification(DeltaTwo.implies(NotDNCinZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, NotAED, CompositeJustification(DeltaTwo.implies(NotDNCinZP), DeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(NotDNCinZP, NotPA, CompositeJustification(HIF.implies(NotDNCinZP), HIF.doesNotImply(NotPA)))
menagerie.setProperty(NotHigh, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotHigh)))
menagerie.setProperty(NotHigh, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(NotHigh)))
menagerie.addImplication(NotHigh, NotPAinZP, CompositeJustification(NotHigh.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(NotHigh, ArrayComp, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(NotHigh, NotPA, CompositeJustification(HIF.implies(NotHigh), HIF.doesNotImply(NotPA)))
menagerie.setProperty(NotPA, "hdim", 1, CompositeJustification(BN1R.hdim, BN1R.implies(NotPA)))
menagerie.setProperty(NotPA, "measure", 1, CompositeJustification(BNSC.measure, BNSC.implies(NotPA)))
menagerie.addImplication(NotPA, NotPAinZP, CompositeJustification(NotPA.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(NotPA, BNDeltaTwo, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotPA, BNHIF, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotPA, BNSC, CompositeJustification(BN1R.implies(NotPA), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(NotPAinZP, BN1G, CompositeJustification(BN1G.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BN1R, CompositeJustification(BN1R.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BNLFO, CompositeJustification(BNLFO.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, NotDNCinZP, CompositeJustification(NotDNCinZP.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, OmegaLow, CompositeJustification(OmegaLow.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, BNDeltaTwo, CompositeJustification(BNDeltaTwo.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, NotHigh, CompositeJustification(NotHigh.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, NotAED, CompositeJustification(NotAED.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, NotPA, CompositeJustification(NotPA.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addImplication(OmegaLow, BNW2G, CompositeJustification(OmegaLow.implies(ArrayComp), ArrayComp.implies(BNW2G)))
menagerie.addImplication(OmegaLow, BOGL2, CompositeJustification(OmegaLow.implies(ArrayComp), ArrayComp.implies(BOGL2)))
menagerie.addImplication(OmegaLow, NotAED, CompositeJustification(OmegaLow.implies(ArrayComp), ArrayComp.implies(NotAED)))
menagerie.addImplication(OmegaLow, NotPAinZP, CompositeJustification(OmegaLow.implies(BNHIF), BNHIF.implies(NotPAinZP)))
menagerie.addImplication(OmegaLow, BN2G, CompositeJustification(OmegaLow.implies(BOGL1), BOGL1.implies(BN2G)))
menagerie.addNonimplication(OmegaLow, BB1G, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(OmegaLow, BN1G, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(OmegaLow, BN1R, CompositeJustification(BN1R.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(OmegaLow, BNLFO, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(OmegaLow, NotHigh, CompositeJustification(BB2R.implies(OmegaLow), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(OmegaLow, BNDeltaTwo, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(OmegaLow, BNmin, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(OmegaLow, BNSC, CompositeJustification(BNSC.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addImplication(SuperLow, BNW2G, CompositeJustification(SuperLow.implies(ArrayComp), ArrayComp.implies(BNW2G)))
menagerie.addImplication(SuperLow, BOGL2, CompositeJustification(SuperLow.implies(ArrayComp), ArrayComp.implies(BOGL2)))
menagerie.addImplication(SuperLow, NotAED, CompositeJustification(SuperLow.implies(ArrayComp), ArrayComp.implies(NotAED)))
menagerie.addImplication(SuperLow, BOGL1, CompositeJustification(SuperLow.implies(Low), Low.implies(BOGL1)))
menagerie.addImplication(SuperLow, DeltaTwo, CompositeJustification(SuperLow.implies(Low), Low.implies(DeltaTwo)))
menagerie.addImplication(SuperLow, NotHigh, CompositeJustification(SuperLow.implies(Low), Low.implies(NotHigh)))
menagerie.addNonimplication(SuperLow, BB1G, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(SuperLow, BB2R, CompositeJustification(BB2R.implies(OmegaLow), SuperLow.doesNotImply(OmegaLow)))
menagerie.addNonimplication(SuperLow, BN1G, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(SuperLow, BNDeltaTwo, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(SuperLow, BNLFO, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(SuperLow, BNmin, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(SuperLow, BN1R, CompositeJustification(BN1R.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.addNonimplication(SuperLow, BNSC, CompositeJustification(BNSC.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.addNonimplication(SuperLow, Low1Rand, CompositeJustification(Low1Rand.implies(OmegaLow), SuperLow.doesNotImply(OmegaLow)))
menagerie.addImplication(NotAED, NotPAinZP, CompositeJustification(NotAED.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.setProperty(BB1G, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(BB1G)))
menagerie.setProperty(BB1G, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(BB1G)))
menagerie.addNonimplication(BB2G, CET, CompositeJustification(BB2G.category, CET.category))
menagerie.addNonimplication(BB2G, DeltaTwo, CompositeJustification(BB2G.cardinality, DeltaTwo.cardinality))
menagerie.setProperty(BB2R, "cardinality", 1, CompositeJustification(BB3R.cardinality, BB3R.implies(BB2R)))
menagerie.setProperty(BB2R, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BB2R)))
menagerie.setProperty(BB2R, "pdim", 1, CompositeJustification(BB3R.pdim, BB3R.implies(BB2R)))
menagerie.addNonimplication(BB3R, CET, CompositeJustification(BB3R.pdim, CET.pdim))
menagerie.addNonimplication(BB3R, DeltaTwo, CompositeJustification(BB3R.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(BB3R, NotDNCinZP, CompositeJustification(BB3R.hdim, NotDNCinZP.hdim))
menagerie.setProperty(BND1, "cardinality", 1, CompositeJustification(BBmin.cardinality, BBmin.implies(BND1)))
menagerie.setProperty(BN1G, "cardinality", 1, CompositeJustification(BBmin.cardinality, BBmin.implies(BN1G)))
menagerie.addNonimplication(BN1R, CET, CompositeJustification(BN1R.hdim, CET.hdim))
menagerie.addNonimplication(BN1R, DeltaTwo, CompositeJustification(BN1R.cardinality, DeltaTwo.cardinality))
menagerie.setProperty(BN2R, "cardinality", 1, CompositeJustification(BN1R.cardinality, BN1R.implies(BN2R)))
menagerie.setProperty(BN2R, "pdim", 1, CompositeJustification(BN1R.pdim, BN1R.implies(BN2R)))
menagerie.setProperty(BNDeltaTwo, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(BNDeltaTwo)))
menagerie.setProperty(BNDeltaTwo, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(BNDeltaTwo)))
menagerie.setProperty(BNHIF, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(BNHIF)))
menagerie.setProperty(BNHIF, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(BNHIF)))
menagerie.addNonimplication(BNLFO, CET, CompositeJustification(BNLFO.hdim, CET.hdim))
menagerie.addNonimplication(BNLFO, DeltaTwo, CompositeJustification(BNLFO.cardinality, DeltaTwo.cardinality))
menagerie.setProperty(BNmin, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(BNmin)))
menagerie.setProperty(BNmin, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(BNmin)))
menagerie.addNonimplication(BNSC, CET, CompositeJustification(BNSC.pdim, CET.pdim))
menagerie.addNonimplication(BNSC, DeltaTwo, CompositeJustification(BNSC.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(BNSC, NotDNCinZP, CompositeJustification(BNSC.hdim, NotDNCinZP.hdim))
menagerie.setProperty(HIF, "measure", 0, CompositeJustification(NotDNCinZP.measure, HIF.implies(NotDNCinZP)))
menagerie.setProperty(JumpTraceable, "category", 0, CompositeJustification(CET.category, JumpTraceable.implies(CET)))
menagerie.setProperty(JumpTraceable, "hdim", 0, CompositeJustification(CET.hdim, JumpTraceable.implies(CET)))
menagerie.setProperty(JumpTraceable, "measure", 0, CompositeJustification(CET.measure, JumpTraceable.implies(CET)))
menagerie.setProperty(Low, "category", 0, CompositeJustification(DeltaTwo.category, Low.implies(DeltaTwo)))
menagerie.setProperty(Low, "hdim", 0, CompositeJustification(DeltaTwo.hdim, Low.implies(DeltaTwo)))
menagerie.setProperty(Low, "pdim", 0, CompositeJustification(DeltaTwo.pdim, Low.implies(DeltaTwo)))
menagerie.setProperty(Low, "measure", 0, CompositeJustification(DeltaTwo.measure, Low.implies(DeltaTwo)))
menagerie.addNonimplication(LowKurtz, DeltaTwo, CompositeJustification(LowKurtz.cardinality, DeltaTwo.cardinality))
menagerie.setProperty(LowSchnorr, "category", 0, CompositeJustification(CET.category, LowSchnorr.implies(CET)))
menagerie.setProperty(LowSchnorr, "hdim", 0, CompositeJustification(CET.hdim, LowSchnorr.implies(CET)))
menagerie.setProperty(LowSchnorr, "measure", 0, CompositeJustification(CET.measure, LowSchnorr.implies(CET)))
menagerie.setProperty(NotAboveZP, "cardinality", 1, CompositeJustification(BNLFO.cardinality, BNLFO.implies(NotAboveZP)))
menagerie.setProperty(NotAboveZP, "pdim", 1, CompositeJustification(BNLFO.pdim, BNLFO.implies(NotAboveZP)))
menagerie.setProperty(NotDNC, "measure", 0, CompositeJustification(NotDNCinZP.measure, NotDNC.implies(NotDNCinZP)))
menagerie.setProperty(NotHigh, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(NotHigh)))
menagerie.setProperty(NotHigh, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(NotHigh)))
menagerie.setProperty(NotHigh, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(NotHigh)))
menagerie.setProperty(NotPA, "cardinality", 1, CompositeJustification(BN1R.cardinality, BN1R.implies(NotPA)))
menagerie.setProperty(NotPA, "pdim", 1, CompositeJustification(BN1R.pdim, BN1R.implies(NotPA)))
menagerie.setProperty(ArrayComp, "cardinality", 1, CompositeJustification(JumpTraceable.cardinality, JumpTraceable.implies(ArrayComp)))
menagerie.setProperty(ArrayComp, "category", 0, CompositeJustification(BN3G.category, ArrayComp.implies(BN3G)))
menagerie.setProperty(ArrayComp, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(ArrayComp)))
menagerie.addImplication(ArrayComp, NotPAinZP, CompositeJustification(ArrayComp.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(ArrayComp, BB1G, CompositeJustification(Low1Rand.implies(ArrayComp), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(ArrayComp, BBmin, CompositeJustification(LowSchnorr.implies(ArrayComp), LowSchnorr.doesNotImply(BBmin)))
menagerie.addNonimplication(ArrayComp, BN1G, CompositeJustification(Low1Rand.implies(ArrayComp), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(ArrayComp, BN1R, CompositeJustification(OmegaLow.implies(ArrayComp), OmegaLow.doesNotImply(BN1R)))
menagerie.addNonimplication(ArrayComp, BNLFO, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(ArrayComp, Low1Rand, CompositeJustification(SuperLow.implies(ArrayComp), SuperLow.doesNotImply(Low1Rand)))
menagerie.addNonimplication(ArrayComp, NotDNC, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(ArrayComp, NotDNCinZP, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(ArrayComp, NotHigh, CompositeJustification(BB2R.implies(ArrayComp), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(ArrayComp, BNDeltaTwo, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(ArrayComp, BNHIF, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(ArrayComp, BNmin, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(ArrayComp, BOGL1, CompositeJustification(BBmin.implies(ArrayComp), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(ArrayComp, BNSC, CompositeJustification(BND1.implies(ArrayComp), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(ArrayComp, BB2R, CompositeJustification(SuperLow.implies(ArrayComp), SuperLow.doesNotImply(BB2R)))
menagerie.addImplication(CET, BN2G, CompositeJustification(CET.implies(BNW2G), BNW2G.implies(BN2G)))
menagerie.addImplication(CET, BN3G, CompositeJustification(CET.implies(BOGL2), BOGL2.implies(BN3G)))
menagerie.addImplication(CET, NotAboveZP, CompositeJustification(CET.implies(BOGL2), BOGL2.implies(NotAboveZP)))
menagerie.addImplication(CET, BN2R, CompositeJustification(CET.implies(NotDNC), NotDNC.implies(BN2R)))
menagerie.addImplication(CET, NotPA, CompositeJustification(CET.implies(NotDNC), NotDNC.implies(NotPA)))
menagerie.addNonimplication(CET, DeltaTwo, CompositeJustification(CET.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(CET, Low, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(Low)))
menagerie.addNonimplication(CET, BB2G, CompositeJustification(JumpTraceable.implies(CET), JumpTraceable.doesNotImply(BB2G)))
menagerie.addNonimplication(CET, BB2R, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(BB2R)))
menagerie.addNonimplication(CET, BB3R, CompositeJustification(BB3R.implies(NotHigh), CET.doesNotImply(NotHigh)))
menagerie.addNonimplication(CET, OmegaLow, CompositeJustification(JumpTraceable.implies(CET), JumpTraceable.doesNotImply(OmegaLow)))
menagerie.addNonimplication(CET, BB1G, CompositeJustification(Low1Rand.implies(CET), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(CET, BN1G, CompositeJustification(Low1Rand.implies(CET), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(CET, BNDeltaTwo, CompositeJustification(Low1Rand.implies(CET), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(CET, BNLFO, CompositeJustification(Low1Rand.implies(CET), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(CET, HIF, CompositeJustification(HIF.implies(NotHigh), CET.doesNotImply(NotHigh)))
menagerie.addNonimplication(CET, JumpTraceable, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(JumpTraceable)))
menagerie.setProperty(BB1G, "hdim", 0, CompositeJustification(NotDNCinZP.hdim, BB1G.implies(NotDNCinZP)))
menagerie.addImplication(BB1G, BN2R, CompositeJustification(BB1G.implies(NotDNC), NotDNC.implies(BN2R)))
menagerie.addImplication(BB1G, NotPA, CompositeJustification(BB1G.implies(NotDNC), NotDNC.implies(NotPA)))
menagerie.addNonimplication(BB1G, BIF, CompositeJustification(BIF.implies(BNDeltaTwo), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BB1G, BN3G, CompositeJustification(BB1G.category, BN3G.category))
menagerie.addNonimplication(BB1G, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), BB1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(BB1G, LowKurtz, CompositeJustification(LowKurtz.implies(BNDeltaTwo), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BB1G, SuperLow, CompositeJustification(SuperLow.implies(NotHigh), BB1G.doesNotImply(NotHigh)))
menagerie.setProperty(BB2G, "measure", 0, CompositeJustification(BN2R.measure, BB2G.implies(BN2R)))
menagerie.addImplication(BB2G, BN1R, CompositeJustification(BB2G.implies(NotDNC), NotDNC.implies(BN1R)))
menagerie.addImplication(BB2G, BNSC, CompositeJustification(BB2G.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addImplication(BB2G, NotDNCinZP, CompositeJustification(BB2G.implies(NotDNC), NotDNC.implies(NotDNCinZP)))
menagerie.addNonimplication(BB2G, BN2G, CompositeJustification(BB2G.category, BN2G.category))
menagerie.addNonimplication(BB2G, BOGL2, CompositeJustification(BB2G.category, BOGL2.category))
menagerie.addImplication(BB2R, NotPAinZP, CompositeJustification(BB2R.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addImplication(BB2R, BN2G, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(BN2G)))
menagerie.addImplication(BB2R, BNW2G, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(BNW2G)))
menagerie.addImplication(BB2R, BOGL2, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(BOGL2)))
menagerie.addImplication(BB2R, NotAED, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(NotAED)))
menagerie.addNonimplication(BB2R, BIF, CompositeJustification(BIF.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB2R, BN2R, CompositeJustification(BB2R.measure, BN2R.measure))
menagerie.addNonimplication(BB2R, LowKurtz, CompositeJustification(LowKurtz.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB2R, SuperLow, CompositeJustification(SuperLow.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addImplication(BB3R, NotPA, CompositeJustification(BB3R.implies(BNmin), BNmin.implies(NotPA)))
menagerie.addImplication(BB3R, NotPAinZP, CompositeJustification(BB3R.implies(NotHigh), NotHigh.implies(NotPAinZP)))
menagerie.addImplication(BB3R, ArrayComp, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(ArrayComp)))
menagerie.addImplication(BB3R, BNHIF, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(BNHIF)))
menagerie.addImplication(BB3R, BOGL1, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(BOGL1)))
menagerie.addNonimplication(BB3R, BN1G, CompositeJustification(BB3R.measure, BN1G.measure))
menagerie.addNonimplication(BB3R, BN1R, CompositeJustification(BB3R.measure, BN1R.measure))
menagerie.addNonimplication(BB3R, BNLFO, CompositeJustification(BB3R.measure, BNLFO.measure))
menagerie.setProperty(BBmin, "measure", 0, CompositeJustification(BN2R.measure, BBmin.implies(BN2R)))
menagerie.addImplication(BBmin, BOGL2, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(BOGL2)))
menagerie.addImplication(BBmin, NotAED, CompositeJustification(BBmin.implies(BN1G), BN1G.implies(NotAED)))
menagerie.addImplication(BBmin, BN3G, CompositeJustification(BBmin.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(BBmin, NotPAinZP, CompositeJustification(BBmin.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(BBmin, FSI, CompositeJustification(FSI.implies(BOGL1), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BBmin, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BBmin, LowSchnorr, CompositeJustification(BBmin.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BBmin, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), BBmin.doesNotImply(BOGL1)))
menagerie.setProperty(BIF, "hdim", 0, CompositeJustification(NotDNCinZP.hdim, BIF.implies(NotDNCinZP)))
menagerie.setProperty(BIF, "measure", 0, CompositeJustification(BN2R.measure, BIF.implies(BN2R)))
menagerie.addImplication(BIF, NotPAinZP, CompositeJustification(BIF.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addImplication(BIF, ArrayComp, CompositeJustification(BIF.implies(HIF), HIF.implies(ArrayComp)))
menagerie.addImplication(BIF, BN2G, CompositeJustification(BIF.implies(HIF), HIF.implies(BN2G)))
menagerie.addImplication(BIF, BNW2G, CompositeJustification(BIF.implies(HIF), HIF.implies(BNW2G)))
menagerie.addImplication(BIF, NotAboveZP, CompositeJustification(BIF.implies(HIF), HIF.implies(NotAboveZP)))
menagerie.addImplication(BIF, NotAED, CompositeJustification(BIF.implies(NotHigh), NotHigh.implies(NotAED)))
menagerie.addNonimplication(BIF, JumpTraceable, CompositeJustification(BIF.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(BIF, Low, CompositeJustification(BIF.cardinality, Low.cardinality))
menagerie.addNonimplication(BIF, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(BIF, LowSchnorr, CompositeJustification(BIF.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BIF, BB3R, CompositeJustification(BB3R.implies(BNmin), BIF.doesNotImply(BNmin)))
menagerie.setProperty(BND1, "measure", 0, CompositeJustification(BN2R.measure, BND1.implies(BN2R)))
menagerie.addImplication(BND1, BOGL2, CompositeJustification(BND1.implies(BN1G), BN1G.implies(BOGL2)))
menagerie.addImplication(BND1, NotAED, CompositeJustification(BND1.implies(BN1G), BN1G.implies(NotAED)))
menagerie.addImplication(BND1, BN3G, CompositeJustification(BND1.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(BND1, NotPAinZP, CompositeJustification(BND1.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(BND1, CET, CompositeJustification(BND1.pdim, CET.pdim))
menagerie.addNonimplication(BND1, DeltaTwo, CompositeJustification(DeltaTwo.implies(BNHIF), BND1.doesNotImply(BNHIF)))
menagerie.addNonimplication(BND1, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BND1.doesNotImply(BOGL1)))
menagerie.addNonimplication(BND1, Low, CompositeJustification(Low.implies(BOGL1), BND1.doesNotImply(BOGL1)))
menagerie.addNonimplication(BND1, BBmin, CompositeJustification(BIF.implies(BND1), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BND1, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BND1.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BND1, BB3R, CompositeJustification(BB3R.implies(BNSC), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BND1, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BND1.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BND1, LowKurtz, CompositeJustification(LowKurtz.implies(BNSC), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BND1, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BND1.doesNotImply(BNHIF)))
menagerie.addNonimplication(BND1, BB1G, CompositeJustification(BB1G.implies(BNSC), BND1.doesNotImply(BNSC)))
menagerie.setProperty(BN1G, "category", 0, CompositeJustification(BN3G.category, BN1G.implies(BN3G)))
menagerie.addNonimplication(BN1G, CET, CompositeJustification(BN1G.pdim, CET.pdim))
menagerie.addNonimplication(BN1G, DeltaTwo, CompositeJustification(DeltaTwo.implies(BNHIF), BN1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN1G, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BN1G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1G, Low, CompositeJustification(Low.implies(BOGL1), BN1G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1G, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), BN1G.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1G, BBmin, CompositeJustification(BIF.implies(BN1G), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BN1G, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BN1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN1G, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BN1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN1G, BB3R, CompositeJustification(BB3R.implies(NotHigh), BN1G.doesNotImply(NotHigh)))
menagerie.addNonimplication(BN1G, BIF, CompositeJustification(LowKurtz.implies(BN1G), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(BN1G, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BN1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN1G, LowKurtz, CompositeJustification(LowKurtz.implies(NotDNC), BN1G.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN1G, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BN1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN1G, BB1G, CompositeJustification(BB1G.implies(NotDNC), BN1G.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN1G, BN1R, CompositeJustification(BN1R.implies(NotPA), BN1G.doesNotImply(NotPA)))
menagerie.setProperty(BN2G, "cardinality", 1, CompositeJustification(JumpTraceable.cardinality, JumpTraceable.implies(BN2G)))
menagerie.setProperty(BN2G, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(BN2G)))
menagerie.addNonimplication(BN2G, BB2G, CompositeJustification(BB2G.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BBmin, CompositeJustification(BBmin.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BND1, CompositeJustification(BND1.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BN1R, CompositeJustification(BN1R.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BN2R, CompositeJustification(BN2R.implies(NotPAinZP), BN2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BN2G, DeltaTwo, CompositeJustification(BOGL1.implies(BN2G), BOGL1.doesNotImply(DeltaTwo)))
menagerie.addNonimplication(BN2G, HIF, CompositeJustification(HIF.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, Low, CompositeJustification(Low.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, Low1Rand, CompositeJustification(Low1Rand.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, NotDNC, CompositeJustification(BBmin.implies(BN2G), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN2G, NotDNCinZP, CompositeJustification(BBmin.implies(BN2G), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(BN2G, BNHIF, CompositeJustification(BBmin.implies(BN2G), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN2G, BNmin, CompositeJustification(BBmin.implies(BN2G), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BN2G, BOGL1, CompositeJustification(BBmin.implies(BN2G), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2G, BNSC, CompositeJustification(BND1.implies(BN2G), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BN2G, BB2R, CompositeJustification(BB2R.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, ArrayComp, CompositeJustification(BOGL1.implies(BN2G), BOGL1.doesNotImply(ArrayComp)))
menagerie.addNonimplication(BN3G, BBmin, CompositeJustification(BBmin.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BND1, CompositeJustification(BND1.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BNLFO, CompositeJustification(BNLFO.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, HIF, CompositeJustification(HIF.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, JumpTraceable, CompositeJustification(JumpTraceable.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, Low, CompositeJustification(Low.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, NotHigh, CompositeJustification(NotHigh.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, BNDeltaTwo, CompositeJustification(BNDeltaTwo.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, ArrayComp, CompositeJustification(ArrayComp.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, OmegaLow, CompositeJustification(OmegaLow.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, NotPAinZP, CompositeJustification(BNW2G.implies(BN3G), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BN3G, NotAED, CompositeJustification(DeltaTwo.implies(BN3G), DeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BN3G, NotPA, CompositeJustification(NotPA.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN1R, ArrayComp, CompositeJustification(ArrayComp.implies(NotAED), BN1R.doesNotImply(NotAED)))
menagerie.addNonimplication(BN1R, BB1G, CompositeJustification(BB1G.implies(BNSC), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1R, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), BN1R.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BN1R, BB3R, CompositeJustification(BB3R.implies(BNSC), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1R, BIF, CompositeJustification(BIF.implies(BNSC), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1R, HIF, CompositeJustification(BN1R.hdim, HIF.hdim))
menagerie.addNonimplication(BN1R, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BN1R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1R, Low, CompositeJustification(Low.implies(BOGL1), BN1R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1R, LowKurtz, CompositeJustification(LowKurtz.implies(BNSC), BN1R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN1R, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BN1R.doesNotImply(BNHIF)))
menagerie.setProperty(BN2R, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BN2R)))
menagerie.addNonimplication(BN2R, BB2G, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(BB2G)))
menagerie.addNonimplication(BN2R, BB2R, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(BB2R)))
menagerie.addNonimplication(BN2R, BBmin, CompositeJustification(BIF.implies(BN2R), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BN2R, BOGL1, CompositeJustification(BBmin.implies(BN2R), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2R, HIF, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(HIF)))
menagerie.addNonimplication(BN2R, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), BN2R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN2R, NotDNC, CompositeJustification(BBmin.implies(BN2R), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN2R, NotDNCinZP, CompositeJustification(BN2R.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(BN2R, BNHIF, CompositeJustification(BBmin.implies(BN2R), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN2R, BNLFO, CompositeJustification(BBmin.implies(BN2R), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(BN2R, BNmin, CompositeJustification(BBmin.implies(BN2R), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BN2R, NotHigh, CompositeJustification(BBmin.implies(BN2R), BBmin.doesNotImply(NotHigh)))
menagerie.addNonimplication(BN2R, NotAboveZP, CompositeJustification(DeltaTwo.implies(BN2R), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2R, NotAED, CompositeJustification(DeltaTwo.implies(BN2R), DeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BN2R, NotPA, CompositeJustification(HIF.implies(BN2R), HIF.doesNotImply(NotPA)))
menagerie.setProperty(BNDeltaTwo, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BNDeltaTwo)))
menagerie.addNonimplication(BNDeltaTwo, CET, CompositeJustification(CET.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, BB2G, CompositeJustification(BB2G.implies(NotHigh), BNDeltaTwo.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNDeltaTwo, BB3R, CompositeJustification(BB3R.implies(NotHigh), BNDeltaTwo.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNDeltaTwo, BBmin, CompositeJustification(BIF.implies(BNDeltaTwo), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BNDeltaTwo, BIF, CompositeJustification(LowKurtz.implies(BNDeltaTwo), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(BNDeltaTwo, BN1G, CompositeJustification(BN1G.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, BN3G, CompositeJustification(BNDeltaTwo.category, BN3G.category))
menagerie.addNonimplication(BNDeltaTwo, BN1R, CompositeJustification(BN1R.implies(NotPA), BNDeltaTwo.doesNotImply(NotPA)))
menagerie.addNonimplication(BNDeltaTwo, HIF, CompositeJustification(HIF.implies(NotHigh), BNDeltaTwo.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNDeltaTwo, Low, CompositeJustification(Low.implies(NotHigh), BNDeltaTwo.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNDeltaTwo, OmegaLow, CompositeJustification(OmegaLow.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, SuperLow, CompositeJustification(SuperLow.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, BNHIF, CompositeJustification(BIF.implies(BNDeltaTwo), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNDeltaTwo, BNmin, CompositeJustification(BIF.implies(BNDeltaTwo), BIF.doesNotImply(BNmin)))
menagerie.addNonimplication(BNDeltaTwo, BNSC, CompositeJustification(BNSC.implies(NotPA), BNDeltaTwo.doesNotImply(NotPA)))
menagerie.addNonimplication(BNHIF, ArrayComp, CompositeJustification(Low.implies(BNHIF), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(BNHIF, BB1G, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BNHIF, BN1G, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(BNHIF, BN3G, CompositeJustification(BNHIF.category, BN3G.category))
menagerie.addNonimplication(BNHIF, BN1R, CompositeJustification(OmegaLow.implies(BNHIF), OmegaLow.doesNotImply(BN1R)))
menagerie.addNonimplication(BNHIF, BNLFO, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(BNHIF, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), BNHIF.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, OmegaLow, CompositeJustification(OmegaLow.implies(NotAboveZP), BNHIF.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, NotHigh, CompositeJustification(BB2R.implies(BNHIF), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNHIF, BNDeltaTwo, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNHIF, BNmin, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(BNHIF, BNSC, CompositeJustification(OmegaLow.implies(BNHIF), OmegaLow.doesNotImply(BNSC)))
menagerie.addNonimplication(BNLFO, BB3R, CompositeJustification(BB3R.implies(BNDeltaTwo), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNLFO, BBmin, CompositeJustification(BIF.implies(BNLFO), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BNLFO, BIF, CompositeJustification(BIF.implies(BNDeltaTwo), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNLFO, BN3G, CompositeJustification(BNLFO.category, BN3G.category))
menagerie.addNonimplication(BNLFO, LowKurtz, CompositeJustification(LowKurtz.implies(BNDeltaTwo), BNLFO.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNLFO, NotDNC, CompositeJustification(BNLFO.hdim, NotDNC.hdim))
menagerie.addNonimplication(BNLFO, BNHIF, CompositeJustification(BIF.implies(BNLFO), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNLFO, BNmin, CompositeJustification(BIF.implies(BNLFO), BIF.doesNotImply(BNmin)))
menagerie.addNonimplication(BNLFO, BN1R, CompositeJustification(BN1R.implies(NotPA), BNLFO.doesNotImply(NotPA)))
menagerie.addNonimplication(BNLFO, BNSC, CompositeJustification(BNSC.implies(NotPA), BNLFO.doesNotImply(NotPA)))
menagerie.setProperty(BNmin, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BNmin)))
menagerie.addImplication(BNmin, NotPAinZP, CompositeJustification(BNmin.implies(NotPA), NotPA.implies(NotPAinZP)))
menagerie.addNonimplication(BNmin, BB3R, CompositeJustification(BB3R.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNmin, BIF, CompositeJustification(BIF.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNmin, BN3G, CompositeJustification(BNmin.category, BN3G.category))
menagerie.addNonimplication(BNmin, Low, CompositeJustification(Low.implies(BNHIF), BNmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNmin, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), BNmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNmin, LowKurtz, CompositeJustification(LowKurtz.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addImplication(BNSC, NotPAinZP, CompositeJustification(BNSC.implies(NotPA), NotPA.implies(NotPAinZP)))
menagerie.addNonimplication(BNSC, ArrayComp, CompositeJustification(ArrayComp.implies(NotAED), BNSC.doesNotImply(NotAED)))
menagerie.addNonimplication(BNSC, BB3R, CompositeJustification(BB3R.implies(BNDeltaTwo), BNSC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNSC, BBmin, CompositeJustification(BIF.implies(BNSC), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BNSC, BIF, CompositeJustification(BIF.implies(BNDeltaTwo), BNSC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNSC, BND1, CompositeJustification(Low1Rand.implies(BNSC), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(BNSC, BN1R, CompositeJustification(BNSC.measure, BN1R.measure))
menagerie.addNonimplication(BNSC, Low, CompositeJustification(Low.implies(NotHigh), BNSC.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNSC, LowKurtz, CompositeJustification(LowKurtz.implies(BNDeltaTwo), BNSC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNSC, BNHIF, CompositeJustification(BB1G.implies(BNSC), BB1G.doesNotImply(BNHIF)))
menagerie.setProperty(BNW2G, "category", 0, CompositeJustification(BN2G.category, BNW2G.implies(BN2G)))
menagerie.setProperty(BNW2G, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(BNW2G)))
menagerie.addNonimplication(BNW2G, BB2G, CompositeJustification(BB2G.implies(NotPAinZP), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BNW2G, BN1G, CompositeJustification(BN1G.implies(NotAboveZP), BNW2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNW2G, BN1R, CompositeJustification(BN1R.implies(NotPAinZP), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BNW2G, BNLFO, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(BNW2G, DeltaTwo, CompositeJustification(DeltaTwo.implies(NotPAinZP), BNW2G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BNW2G, NotDNC, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BNW2G, NotDNCinZP, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(BNW2G, NotHigh, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNW2G, BNDeltaTwo, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNW2G, BNmin, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BNW2G, BOGL1, CompositeJustification(BBmin.implies(BNW2G), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNW2G, BNSC, CompositeJustification(BND1.implies(BNW2G), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BNW2G, OmegaLow, CompositeJustification(OmegaLow.implies(NotAboveZP), BNW2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNW2G, NotPA, CompositeJustification(HIF.implies(BNW2G), HIF.doesNotImply(NotPA)))
menagerie.addNonimplication(BNW2G, ArrayComp, CompositeJustification(Low.implies(BNW2G), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(BNW2G, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), BNW2G.doesNotImply(NotAboveZP)))
menagerie.setProperty(BOGL1, "category", 0, CompositeJustification(BN2G.category, BOGL1.implies(BN2G)))
menagerie.addImplication(BOGL1, NotPAinZP, CompositeJustification(BOGL1.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(BOGL1, CET, CompositeJustification(CET.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, BB1G, CompositeJustification(Low1Rand.implies(BOGL1), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BOGL1, BB2G, CompositeJustification(JumpTraceable.implies(BOGL1), JumpTraceable.doesNotImply(BB2G)))
menagerie.addNonimplication(BOGL1, BBmin, CompositeJustification(BBmin.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, BND1, CompositeJustification(BND1.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, BN1R, CompositeJustification(OmegaLow.implies(BOGL1), OmegaLow.doesNotImply(BN1R)))
menagerie.addNonimplication(BOGL1, BNLFO, CompositeJustification(Low1Rand.implies(BOGL1), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(BOGL1, HIF, CompositeJustification(HIF.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, Low, CompositeJustification(Low.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, SuperLow, CompositeJustification(SuperLow.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, BB3R, CompositeJustification(BB3R.implies(NotHigh), BOGL1.doesNotImply(NotHigh)))
menagerie.addNonimplication(BOGL1, OmegaLow, CompositeJustification(OmegaLow.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, BNDeltaTwo, CompositeJustification(Low1Rand.implies(BOGL1), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BOGL1, BNmin, CompositeJustification(Low1Rand.implies(BOGL1), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(BOGL1, BNSC, CompositeJustification(OmegaLow.implies(BOGL1), OmegaLow.doesNotImply(BNSC)))
menagerie.setProperty(BOGL2, "cardinality", 1, CompositeJustification(JumpTraceable.cardinality, JumpTraceable.implies(BOGL2)))
menagerie.addNonimplication(BOGL2, BBmin, CompositeJustification(BBmin.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BND1, CompositeJustification(BND1.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, HIF, CompositeJustification(HIF.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, JumpTraceable, CompositeJustification(JumpTraceable.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, Low, CompositeJustification(Low.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, NotHigh, CompositeJustification(JumpTraceable.implies(BOGL2), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(BOGL2, BNHIF, CompositeJustification(JumpTraceable.implies(BOGL2), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(BOGL2, ArrayComp, CompositeJustification(ArrayComp.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, OmegaLow, CompositeJustification(OmegaLow.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, NotPA, CompositeJustification(OmegaLow.implies(BOGL2), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(DeltaTwo, CET, CompositeJustification(Low.implies(DeltaTwo), Low.doesNotImply(CET)))
menagerie.addNonimplication(DeltaTwo, BB2R, CompositeJustification(BB2R.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BBmin, CompositeJustification(BBmin.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BND1, CompositeJustification(BND1.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, HIF, CompositeJustification(HIF.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, Low1Rand, CompositeJustification(Low1Rand.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, SuperLow, CompositeJustification(Low.implies(DeltaTwo), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(DeltaTwo, BB2G, CompositeJustification(BB2G.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BNmin, CompositeJustification(BNmin.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BN1R, CompositeJustification(BN1R.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BNSC, CompositeJustification(BNSC.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, BOGL1, CompositeJustification(BOGL1.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, Low, CompositeJustification(Low.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.setProperty(FSI, "pdim", 0, CompositeJustification(CET.pdim, FSI.implies(CET)))
menagerie.addImplication(FSI, ArrayComp, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(ArrayComp)))
menagerie.addImplication(FSI, BN2G, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(BN2G)))
menagerie.addImplication(FSI, BOGL2, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(BOGL2)))
menagerie.addImplication(FSI, NotDNC, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(NotDNC)))
menagerie.addNonimplication(FSI, Low, CompositeJustification(FSI.cardinality, Low.cardinality))
menagerie.addNonimplication(FSI, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), FSI.doesNotImply(BNHIF)))
menagerie.addNonimplication(FSI, BB2R, CompositeJustification(BB2R.implies(BNHIF), FSI.doesNotImply(BNHIF)))
menagerie.addNonimplication(FSI, BBmin, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BBmin)))
menagerie.addNonimplication(FSI, BND1, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(FSI, HIF, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(HIF)))
menagerie.addImplication(HIF, BOGL2, CompositeJustification(HIF.implies(BN1G), BN1G.implies(BOGL2)))
menagerie.addImplication(HIF, BN3G, CompositeJustification(HIF.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(HIF, NotPAinZP, CompositeJustification(HIF.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(HIF, CET, CompositeJustification(HIF.pdim, CET.pdim))
menagerie.addNonimplication(HIF, DeltaTwo, CompositeJustification(HIF.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(HIF, Low1Rand, CompositeJustification(Low1Rand.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.addNonimplication(HIF, BB2G, CompositeJustification(BB2G.implies(BNHIF), HIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(HIF, BB2R, CompositeJustification(BB2R.implies(BNmin), HIF.doesNotImply(BNmin)))
menagerie.addNonimplication(HIF, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), HIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(HIF, BOGL1, CompositeJustification(LowSchnorr.implies(HIF), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(HIF, BND1, CompositeJustification(BND1.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.addNonimplication(HIF, NotDNC, CompositeJustification(NotDNC.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.addImplication(JumpTraceable, BNW2G, CompositeJustification(JumpTraceable.implies(CET), CET.implies(BNW2G)))
menagerie.addImplication(JumpTraceable, NotAED, CompositeJustification(JumpTraceable.implies(CET), CET.implies(NotAED)))
menagerie.addImplication(JumpTraceable, BN3G, CompositeJustification(JumpTraceable.implies(BOGL1), BOGL1.implies(BN3G)))
menagerie.addImplication(JumpTraceable, NotAboveZP, CompositeJustification(JumpTraceable.implies(BOGL2), BOGL2.implies(NotAboveZP)))
menagerie.addImplication(JumpTraceable, BN1R, CompositeJustification(JumpTraceable.implies(NotDNC), NotDNC.implies(BN1R)))
menagerie.addImplication(JumpTraceable, BNSC, CompositeJustification(JumpTraceable.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addImplication(JumpTraceable, NotDNCinZP, CompositeJustification(JumpTraceable.implies(NotDNC), NotDNC.implies(NotDNCinZP)))
menagerie.addNonimplication(JumpTraceable, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(JumpTraceable, SuperLow, CompositeJustification(SuperLow.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(JumpTraceable, BB2R, CompositeJustification(BB2R.implies(BNHIF), JumpTraceable.doesNotImply(BNHIF)))
menagerie.addNonimplication(JumpTraceable, BBmin, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BBmin)))
menagerie.addNonimplication(JumpTraceable, BIF, CompositeJustification(BIF.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(JumpTraceable, BND1, CompositeJustification(Low1Rand.implies(JumpTraceable), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(JumpTraceable, LowKurtz, CompositeJustification(LowKurtz.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addImplication(Low, BN3G, CompositeJustification(Low.implies(BOGL1), BOGL1.implies(BN3G)))
menagerie.addImplication(Low, NotPAinZP, CompositeJustification(Low.implies(DeltaTwo), DeltaTwo.implies(NotPAinZP)))
menagerie.addImplication(Low, BN2R, CompositeJustification(Low.implies(NotDNCinZP), NotDNCinZP.implies(BN2R)))
menagerie.addNonimplication(Low, BB2R, CompositeJustification(BB2R.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, BBmin, CompositeJustification(BBmin.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, BND1, CompositeJustification(BND1.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, HIF, CompositeJustification(HIF.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, JumpTraceable, CompositeJustification(JumpTraceable.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, Low1Rand, CompositeJustification(Low1Rand.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, LowSchnorr, CompositeJustification(LowSchnorr.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, BB1G, CompositeJustification(Low1Rand.implies(Low), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(Low, BNDeltaTwo, CompositeJustification(Low1Rand.implies(Low), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(Low, BNLFO, CompositeJustification(Low1Rand.implies(Low), Low1Rand.doesNotImply(BNLFO)))
menagerie.addNonimplication(Low, BNmin, CompositeJustification(Low1Rand.implies(Low), Low1Rand.doesNotImply(BNmin)))
menagerie.addNonimplication(Low, BN1R, CompositeJustification(SuperLow.implies(Low), SuperLow.doesNotImply(BN1R)))
menagerie.addNonimplication(Low, BNSC, CompositeJustification(SuperLow.implies(Low), SuperLow.doesNotImply(BNSC)))
menagerie.setProperty(Low1Rand, "pdim", 0, CompositeJustification(JumpTraceable.pdim, Low1Rand.implies(JumpTraceable)))
menagerie.addImplication(Low1Rand, BN2G, CompositeJustification(Low1Rand.implies(JumpTraceable), JumpTraceable.implies(BN2G)))
menagerie.addImplication(Low1Rand, BNW2G, CompositeJustification(Low1Rand.implies(OmegaLow), OmegaLow.implies(BNW2G)))
menagerie.addImplication(Low1Rand, BOGL2, CompositeJustification(Low1Rand.implies(JumpTraceable), JumpTraceable.implies(BOGL2)))
menagerie.addImplication(Low1Rand, NotDNC, CompositeJustification(Low1Rand.implies(JumpTraceable), JumpTraceable.implies(NotDNC)))
menagerie.addImplication(Low1Rand, NotAED, CompositeJustification(Low1Rand.implies(OmegaLow), OmegaLow.implies(NotAED)))
menagerie.addImplication(Low1Rand, NotPAinZP, CompositeJustification(Low1Rand.implies(OmegaLow), OmegaLow.implies(NotPAinZP)))
menagerie.addImplication(Low1Rand, DeltaTwo, CompositeJustification(Low1Rand.implies(SuperLow), SuperLow.implies(DeltaTwo)))
menagerie.addImplication(Low1Rand, NotHigh, CompositeJustification(Low1Rand.implies(SuperLow), SuperLow.implies(NotHigh)))
menagerie.addNonimplication(Low1Rand, BIF, CompositeJustification(BIF.implies(BN1G), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(Low1Rand, LowKurtz, CompositeJustification(LowKurtz.implies(BN1G), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(Low1Rand, BB3R, CompositeJustification(BB3R.implies(BNDeltaTwo), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.setProperty(LowKurtz, "hdim", 0, CompositeJustification(HIF.hdim, LowKurtz.implies(HIF)))
menagerie.addImplication(LowKurtz, ArrayComp, CompositeJustification(LowKurtz.implies(BN1G), BN1G.implies(ArrayComp)))
menagerie.addImplication(LowKurtz, BN2G, CompositeJustification(LowKurtz.implies(BN1G), BN1G.implies(BN2G)))
menagerie.addImplication(LowKurtz, BN2R, CompositeJustification(LowKurtz.implies(BN1G), BN1G.implies(BN2R)))
menagerie.addImplication(LowKurtz, BNW2G, CompositeJustification(LowKurtz.implies(BN1G), BN1G.implies(BNW2G)))
menagerie.addImplication(LowKurtz, NotAboveZP, CompositeJustification(LowKurtz.implies(BN1G), BN1G.implies(NotAboveZP)))
menagerie.addImplication(LowKurtz, NotAED, CompositeJustification(LowKurtz.implies(NotHigh), NotHigh.implies(NotAED)))
menagerie.addImplication(LowKurtz, NotPA, CompositeJustification(LowKurtz.implies(BN1R), BN1R.implies(NotPA)))
menagerie.addNonimplication(LowKurtz, JumpTraceable, CompositeJustification(LowKurtz.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(LowKurtz, Low, CompositeJustification(LowSchnorr.implies(LowKurtz), LowSchnorr.doesNotImply(Low)))
menagerie.addNonimplication(LowKurtz, LowSchnorr, CompositeJustification(LowKurtz.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(LowKurtz, BB2G, CompositeJustification(BB2G.implies(BNHIF), LowKurtz.doesNotImply(BNHIF)))
menagerie.addNonimplication(LowKurtz, BB2R, CompositeJustification(BB2R.implies(BNmin), LowKurtz.doesNotImply(BNmin)))
menagerie.addNonimplication(LowKurtz, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), LowKurtz.doesNotImply(BNHIF)))
menagerie.addImplication(LowSchnorr, BNW2G, CompositeJustification(LowSchnorr.implies(CET), CET.implies(BNW2G)))
menagerie.addImplication(LowSchnorr, BOGL2, CompositeJustification(LowSchnorr.implies(CET), CET.implies(BOGL2)))
menagerie.addImplication(LowSchnorr, NotAED, CompositeJustification(LowSchnorr.implies(CET), CET.implies(NotAED)))
menagerie.addImplication(LowSchnorr, BN1G, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(BN1G)))
menagerie.addImplication(LowSchnorr, BN1R, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(BN1R)))
menagerie.addImplication(LowSchnorr, BNDeltaTwo, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(BNDeltaTwo)))
menagerie.addImplication(LowSchnorr, BNLFO, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(BNLFO)))
menagerie.addImplication(LowSchnorr, NotDNCinZP, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(NotDNCinZP)))
menagerie.addImplication(LowSchnorr, NotHigh, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(NotHigh)))
menagerie.addImplication(LowSchnorr, BNSC, CompositeJustification(LowSchnorr.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addNonimplication(LowSchnorr, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), LowSchnorr.doesNotImply(BNHIF)))
menagerie.addNonimplication(LowSchnorr, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(LowSchnorr, BB3R, CompositeJustification(BB3R.implies(BNmin), LowSchnorr.doesNotImply(BNmin)))
menagerie.addNonimplication(LowSchnorr, FSI, CompositeJustification(FSI.implies(BOGL1), LowSchnorr.doesNotImply(BOGL1)))
menagerie.setProperty(NotAboveZP, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotAboveZP)))
menagerie.setProperty(NotAboveZP, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(NotAboveZP)))
menagerie.addNonimplication(NotAboveZP, ArrayComp, CompositeJustification(Low.implies(NotAboveZP), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(NotAboveZP, BB1G, CompositeJustification(Low1Rand.implies(NotAboveZP), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(NotAboveZP, BB2G, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(BB2G)))
menagerie.addNonimplication(NotAboveZP, BB2R, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(BB2R)))
menagerie.addNonimplication(NotAboveZP, BN1G, CompositeJustification(BOGL2.implies(NotAboveZP), BOGL2.doesNotImply(BN1G)))
menagerie.addNonimplication(NotAboveZP, BN1R, CompositeJustification(OmegaLow.implies(NotAboveZP), OmegaLow.doesNotImply(BN1R)))
menagerie.addNonimplication(NotAboveZP, BNLFO, CompositeJustification(BBmin.implies(NotAboveZP), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(NotAboveZP, BNW2G, CompositeJustification(BOGL1.implies(NotAboveZP), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(NotAboveZP, BOGL1, CompositeJustification(BBmin.implies(NotAboveZP), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotAboveZP, DeltaTwo, CompositeJustification(BOGL2.implies(NotAboveZP), BOGL2.doesNotImply(DeltaTwo)))
menagerie.addNonimplication(NotAboveZP, HIF, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(HIF)))
menagerie.addNonimplication(NotAboveZP, NotDNC, CompositeJustification(BBmin.implies(NotAboveZP), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(NotAboveZP, NotDNCinZP, CompositeJustification(NotAboveZP.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(NotAboveZP, BNHIF, CompositeJustification(BBmin.implies(NotAboveZP), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotAboveZP, BNmin, CompositeJustification(BBmin.implies(NotAboveZP), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(NotAboveZP, NotHigh, CompositeJustification(BB2R.implies(NotAboveZP), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotAboveZP, BNSC, CompositeJustification(BND1.implies(NotAboveZP), BND1.doesNotImply(BNSC)))
menagerie.setProperty(NotDNC, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotDNC)))
menagerie.addImplication(NotDNC, NotPAinZP, CompositeJustification(NotDNC.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addImplication(NotDNC, NotAboveZP, CompositeJustification(NotDNC.implies(NotPA), NotPA.implies(NotAboveZP)))
menagerie.addNonimplication(NotDNC, CET, CompositeJustification(NotDNC.pdim, CET.pdim))
menagerie.addNonimplication(NotDNC, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), NotDNC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNC, BB3R, CompositeJustification(BB3R.implies(NotHigh), NotDNC.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotDNC, BN1G, CompositeJustification(BN1G.implies(NotAED), NotDNC.doesNotImply(NotAED)))
menagerie.addNonimplication(NotDNC, BOGL1, CompositeJustification(LowSchnorr.implies(NotDNC), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotDNC, DeltaTwo, CompositeJustification(NotDNC.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(NotDNC, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), NotDNC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNC, Low, CompositeJustification(Low.implies(NotHigh), NotDNC.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotDNC, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), NotDNC.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotDNC, SuperLow, CompositeJustification(SuperLow.implies(NotAED), NotDNC.doesNotImply(NotAED)))
menagerie.addNonimplication(NotDNC, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), NotDNC.doesNotImply(BNDeltaTwo)))
menagerie.setProperty(NotDNCinZP, "cardinality", 1, CompositeJustification(BIF.cardinality, BIF.implies(NotDNCinZP)))
menagerie.setProperty(NotDNCinZP, "pdim", 1, CompositeJustification(BIF.pdim, BIF.implies(NotDNCinZP)))
menagerie.addNonimplication(NotDNCinZP, ArrayComp, CompositeJustification(Low.implies(NotDNCinZP), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(NotDNCinZP, BBmin, CompositeJustification(BIF.implies(NotDNCinZP), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(NotDNCinZP, BIF, CompositeJustification(LowKurtz.implies(NotDNCinZP), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(NotDNCinZP, BN1G, CompositeJustification(BN1G.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, OmegaLow, CompositeJustification(OmegaLow.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, BNDeltaTwo, CompositeJustification(BB1G.implies(NotDNCinZP), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNCinZP, BNHIF, CompositeJustification(BB1G.implies(NotDNCinZP), BB1G.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotDNCinZP, BNLFO, CompositeJustification(BB1G.implies(NotDNCinZP), BB1G.doesNotImply(BNLFO)))
menagerie.addNonimplication(NotDNCinZP, BNmin, CompositeJustification(BB1G.implies(NotDNCinZP), BB1G.doesNotImply(BNmin)))
menagerie.addNonimplication(NotDNCinZP, NotHigh, CompositeJustification(BB1G.implies(NotDNCinZP), BB1G.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotDNCinZP, BN1R, CompositeJustification(BN1R.implies(NotPA), NotDNCinZP.doesNotImply(NotPA)))
menagerie.addNonimplication(NotDNCinZP, BNSC, CompositeJustification(BNSC.implies(NotPA), NotDNCinZP.doesNotImply(NotPA)))
menagerie.addNonimplication(NotHigh, CET, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(CET)))
menagerie.addNonimplication(NotHigh, BBmin, CompositeJustification(BIF.implies(NotHigh), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(NotHigh, BIF, CompositeJustification(LowKurtz.implies(NotHigh), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(NotHigh, BN1G, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(BN1G)))
menagerie.addNonimplication(NotHigh, BN3G, CompositeJustification(NotHigh.category, BN3G.category))
menagerie.addNonimplication(NotHigh, BN1R, CompositeJustification(BN1R.implies(NotPA), NotHigh.doesNotImply(NotPA)))
menagerie.addNonimplication(NotHigh, BN2R, CompositeJustification(NotHigh.measure, BN2R.measure))
menagerie.addNonimplication(NotHigh, OmegaLow, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(OmegaLow)))
menagerie.addNonimplication(NotHigh, SuperLow, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(NotHigh, BNHIF, CompositeJustification(BIF.implies(NotHigh), BIF.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotHigh, BNmin, CompositeJustification(BIF.implies(NotHigh), BIF.doesNotImply(BNmin)))
menagerie.addNonimplication(NotHigh, BNSC, CompositeJustification(BNSC.implies(NotPA), NotHigh.doesNotImply(NotPA)))
menagerie.setProperty(NotPA, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotPA)))
menagerie.addNonimplication(NotPA, BB1G, CompositeJustification(Low1Rand.implies(NotPA), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(NotPA, BB2G, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(BB2G)))
menagerie.addNonimplication(NotPA, BB2R, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(BB2R)))
menagerie.addNonimplication(NotPA, BBmin, CompositeJustification(BIF.implies(NotPA), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(NotPA, BN1G, CompositeJustification(Low1Rand.implies(NotPA), Low1Rand.doesNotImply(BN1G)))
menagerie.addNonimplication(NotPA, BN2R, CompositeJustification(NotPA.measure, BN2R.measure))
menagerie.addNonimplication(NotPA, BNLFO, CompositeJustification(BBmin.implies(NotPA), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(NotPA, BOGL1, CompositeJustification(BBmin.implies(NotPA), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotPA, DeltaTwo, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(DeltaTwo)))
menagerie.addNonimplication(NotPA, HIF, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(HIF)))
menagerie.addNonimplication(NotPA, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), NotPA.doesNotImply(BNSC)))
menagerie.addNonimplication(NotPA, NotDNC, CompositeJustification(BBmin.implies(NotPA), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(NotPA, NotDNCinZP, CompositeJustification(NotPA.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(NotPA, OmegaLow, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(OmegaLow)))
menagerie.addNonimplication(NotPA, BNmin, CompositeJustification(BBmin.implies(NotPA), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(NotPA, NotHigh, CompositeJustification(BB2R.implies(NotPA), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotPA, NotAED, CompositeJustification(NotDNC.implies(NotPA), NotDNC.doesNotImply(NotAED)))
menagerie.setProperty(NotPAinZP, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotPAinZP)))
menagerie.setProperty(NotPAinZP, "hdim", 1, CompositeJustification(BN1R.hdim, BN1R.implies(NotPAinZP)))
menagerie.addNonimplication(NotPAinZP, ArrayComp, CompositeJustification(ArrayComp.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, BB2G, CompositeJustification(BB2G.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BB2R, CompositeJustification(BB2R.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, BBmin, CompositeJustification(BBmin.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BIF, CompositeJustification(BIF.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BND1, CompositeJustification(BND1.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BN2G, CompositeJustification(BOGL2.implies(NotPAinZP), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(NotPAinZP, BOGL1, CompositeJustification(BOGL1.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, DeltaTwo, CompositeJustification(DeltaTwo.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, HIF, CompositeJustification(HIF.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, Low, CompositeJustification(Low.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, Low1Rand, CompositeJustification(Low1Rand.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, NotDNC, CompositeJustification(NotDNC.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BNmin, CompositeJustification(BNmin.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, BNSC, CompositeJustification(BN1R.implies(NotPAinZP), BN1R.doesNotImply(BNSC)))
menagerie.setProperty(OmegaLow, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(OmegaLow)))
menagerie.addImplication(OmegaLow, BN3G, CompositeJustification(OmegaLow.implies(BOGL1), BOGL1.implies(BN3G)))
menagerie.addNonimplication(OmegaLow, BB2G, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BB2G)))
menagerie.addNonimplication(OmegaLow, BBmin, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BBmin)))
menagerie.addNonimplication(OmegaLow, BIF, CompositeJustification(BIF.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(OmegaLow, BND1, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(OmegaLow, HIF, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(HIF)))
menagerie.addNonimplication(OmegaLow, Low, CompositeJustification(Low.implies(NotHigh), OmegaLow.doesNotImply(NotHigh)))
menagerie.addNonimplication(OmegaLow, Low1Rand, CompositeJustification(Low1Rand.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(OmegaLow, NotDNC, CompositeJustification(NotDNC.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(OmegaLow, BB2R, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(BB2R)))
menagerie.addNonimplication(OmegaLow, BB3R, CompositeJustification(BB3R.implies(NotHigh), OmegaLow.doesNotImply(NotHigh)))
menagerie.setProperty(SuperLow, "cardinality", 0, CompositeJustification(Low.cardinality, SuperLow.implies(Low)))
menagerie.addImplication(SuperLow, BN2G, CompositeJustification(SuperLow.implies(BNW2G), BNW2G.implies(BN2G)))
menagerie.addImplication(SuperLow, BN3G, CompositeJustification(SuperLow.implies(BOGL2), BOGL2.implies(BN3G)))
menagerie.addImplication(SuperLow, NotAboveZP, CompositeJustification(SuperLow.implies(BOGL2), BOGL2.implies(NotAboveZP)))
menagerie.addImplication(SuperLow, BNHIF, CompositeJustification(SuperLow.implies(Low), Low.implies(BNHIF)))
menagerie.addImplication(SuperLow, NotDNCinZP, CompositeJustification(SuperLow.implies(Low), Low.implies(NotDNCinZP)))
menagerie.addNonimplication(SuperLow, BB2G, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BB2G)))
menagerie.addNonimplication(SuperLow, BB3R, CompositeJustification(BB3R.implies(OmegaLow), SuperLow.doesNotImply(OmegaLow)))
menagerie.addNonimplication(SuperLow, BBmin, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BBmin)))
menagerie.addNonimplication(SuperLow, BIF, CompositeJustification(BIF.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.addNonimplication(SuperLow, BND1, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(SuperLow, HIF, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(HIF)))
menagerie.addNonimplication(SuperLow, NotDNC, CompositeJustification(NotDNC.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.setProperty(NotAED, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotAED)))
menagerie.setProperty(NotAED, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(NotAED)))
menagerie.addNonimplication(NotAED, ArrayComp, CompositeJustification(Low.implies(NotAED), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(NotAED, OmegaLow, CompositeJustification(SuperLow.implies(NotAED), SuperLow.doesNotImply(OmegaLow)))
menagerie.addNonimplication(NotAED, NotPA, CompositeJustification(HIF.implies(NotAED), HIF.doesNotImply(NotPA)))
menagerie.setProperty(BB1G, "measure", 0, CompositeJustification(NotDNCinZP.measure, BB1G.implies(NotDNCinZP)))
menagerie.addNonimplication(BB1G, CET, CompositeJustification(BB1G.category, CET.category))
menagerie.addNonimplication(BB2G, JumpTraceable, CompositeJustification(BB2G.category, JumpTraceable.category))
menagerie.addNonimplication(BB2G, Low, CompositeJustification(BB2G.cardinality, Low.cardinality))
menagerie.addNonimplication(BB2G, LowSchnorr, CompositeJustification(BB2G.category, LowSchnorr.category))
menagerie.addNonimplication(BB2R, CET, CompositeJustification(BB2R.pdim, CET.pdim))
menagerie.addNonimplication(BB2R, DeltaTwo, CompositeJustification(BB2R.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(BB2R, NotDNCinZP, CompositeJustification(BB2R.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(BB3R, HIF, CompositeJustification(BB3R.hdim, HIF.hdim))
menagerie.addNonimplication(BB3R, JumpTraceable, CompositeJustification(BB3R.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(BB3R, Low, CompositeJustification(BB3R.cardinality, Low.cardinality))
menagerie.addNonimplication(BB3R, LowSchnorr, CompositeJustification(BB3R.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BB3R, NotDNC, CompositeJustification(BB3R.hdim, NotDNC.hdim))
menagerie.addNonimplication(BN1R, LowSchnorr, CompositeJustification(BN1R.hdim, LowSchnorr.hdim))
menagerie.addNonimplication(BN2R, CET, CompositeJustification(BN2R.hdim, CET.hdim))
menagerie.addNonimplication(BN2R, DeltaTwo, CompositeJustification(BN2R.cardinality, DeltaTwo.cardinality))
menagerie.setProperty(BNDeltaTwo, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BNDeltaTwo)))
menagerie.addNonimplication(BNDeltaTwo, DeltaTwo, CompositeJustification(BNDeltaTwo.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(BNHIF, CET, CompositeJustification(BNHIF.category, CET.category))
menagerie.addNonimplication(BNHIF, DeltaTwo, CompositeJustification(BNHIF.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(BNLFO, JumpTraceable, CompositeJustification(BNLFO.hdim, JumpTraceable.hdim))
menagerie.addNonimplication(BNLFO, Low, CompositeJustification(BNLFO.cardinality, Low.cardinality))
menagerie.addNonimplication(BNLFO, LowSchnorr, CompositeJustification(BNLFO.hdim, LowSchnorr.hdim))
menagerie.setProperty(BNmin, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BNmin)))
menagerie.addNonimplication(BNmin, CET, CompositeJustification(BNmin.category, CET.category))
menagerie.addNonimplication(BNSC, JumpTraceable, CompositeJustification(BNSC.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(BNSC, LowSchnorr, CompositeJustification(BNSC.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BNSC, NotDNC, CompositeJustification(BNSC.hdim, NotDNC.hdim))
menagerie.setProperty(BNW2G, "cardinality", 1, CompositeJustification(BBmin.cardinality, BBmin.implies(BNW2G)))
menagerie.setProperty(FSI, "category", 0, CompositeJustification(CET.category, FSI.implies(CET)))
menagerie.setProperty(FSI, "hdim", 0, CompositeJustification(CET.hdim, FSI.implies(CET)))
menagerie.setProperty(FSI, "measure", 0, CompositeJustification(CET.measure, FSI.implies(CET)))
menagerie.setProperty(Low1Rand, "category", 0, CompositeJustification(JumpTraceable.category, Low1Rand.implies(JumpTraceable)))
menagerie.setProperty(Low1Rand, "hdim", 0, CompositeJustification(JumpTraceable.hdim, Low1Rand.implies(JumpTraceable)))
menagerie.setProperty(Low1Rand, "measure", 0, CompositeJustification(JumpTraceable.measure, Low1Rand.implies(JumpTraceable)))
menagerie.setProperty(LowKurtz, "measure", 0, CompositeJustification(HIF.measure, LowKurtz.implies(HIF)))
menagerie.addNonimplication(NotAboveZP, CET, CompositeJustification(NotAboveZP.hdim, CET.hdim))
menagerie.addNonimplication(NotHigh, DeltaTwo, CompositeJustification(NotHigh.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(NotHigh, NotDNCinZP, CompositeJustification(NotHigh.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(NotPA, CET, CompositeJustification(NotPA.hdim, CET.hdim))
menagerie.setProperty(NotPAinZP, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(NotPAinZP)))
menagerie.setProperty(NotPAinZP, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(NotPAinZP)))
menagerie.setProperty(OmegaLow, "cardinality", 1, CompositeJustification(BB3R.cardinality, BB3R.implies(OmegaLow)))
menagerie.setProperty(OmegaLow, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(OmegaLow)))
menagerie.setProperty(OmegaLow, "pdim", 1, CompositeJustification(BB3R.pdim, BB3R.implies(OmegaLow)))
menagerie.setProperty(SuperLow, "category", 0, CompositeJustification(Low.category, SuperLow.implies(Low)))
menagerie.setProperty(SuperLow, "hdim", 0, CompositeJustification(Low.hdim, SuperLow.implies(Low)))
menagerie.setProperty(SuperLow, "pdim", 0, CompositeJustification(Low.pdim, SuperLow.implies(Low)))
menagerie.setProperty(SuperLow, "measure", 0, CompositeJustification(Low.measure, SuperLow.implies(Low)))
menagerie.setProperty(NotAED, "cardinality", 1, CompositeJustification(BB2G.cardinality, BB2G.implies(NotAED)))
menagerie.setProperty(NotAED, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(NotAED)))
menagerie.setProperty(NotAED, "pdim", 1, CompositeJustification(BB2G.pdim, BB2G.implies(NotAED)))
menagerie.setProperty(ArrayComp, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(ArrayComp)))
menagerie.addNonimplication(ArrayComp, CET, CompositeJustification(ArrayComp.pdim, CET.pdim))
menagerie.addNonimplication(ArrayComp, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), ArrayComp.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(ArrayComp, BIF, CompositeJustification(LowKurtz.implies(ArrayComp), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(ArrayComp, BND1, CompositeJustification(Low1Rand.implies(ArrayComp), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(ArrayComp, DeltaTwo, CompositeJustification(ArrayComp.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(ArrayComp, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), ArrayComp.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(ArrayComp, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), ArrayComp.doesNotImply(BOGL1)))
menagerie.addNonimplication(ArrayComp, Low, CompositeJustification(Low.implies(BOGL1), ArrayComp.doesNotImply(BOGL1)))
menagerie.addNonimplication(ArrayComp, LowKurtz, CompositeJustification(LowKurtz.implies(NotDNC), ArrayComp.doesNotImply(NotDNC)))
menagerie.addNonimplication(ArrayComp, BB3R, CompositeJustification(BB3R.implies(NotHigh), ArrayComp.doesNotImply(NotHigh)))
menagerie.addImplication(CET, NotPAinZP, CompositeJustification(CET.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addNonimplication(CET, Low1Rand, CompositeJustification(JumpTraceable.implies(CET), JumpTraceable.doesNotImply(Low1Rand)))
menagerie.addNonimplication(CET, SuperLow, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(SuperLow)))
menagerie.addNonimplication(CET, BIF, CompositeJustification(BIF.implies(NotHigh), CET.doesNotImply(NotHigh)))
menagerie.addNonimplication(CET, BND1, CompositeJustification(Low1Rand.implies(CET), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(CET, LowKurtz, CompositeJustification(LowKurtz.implies(NotHigh), CET.doesNotImply(NotHigh)))
menagerie.addNonimplication(CET, FSI, CompositeJustification(LowSchnorr.implies(CET), LowSchnorr.doesNotImply(FSI)))
menagerie.addImplication(BB1G, NotPAinZP, CompositeJustification(BB1G.implies(NotDNC), NotDNC.implies(NotPAinZP)))
menagerie.addImplication(BB1G, NotAboveZP, CompositeJustification(BB1G.implies(NotPA), NotPA.implies(NotAboveZP)))
menagerie.addNonimplication(BB1G, BN2G, CompositeJustification(BB1G.category, BN2G.category))
menagerie.addNonimplication(BB1G, BOGL2, CompositeJustification(BB1G.category, BOGL2.category))
menagerie.addNonimplication(BB1G, LowSchnorr, CompositeJustification(LowSchnorr.implies(BNDeltaTwo), BB1G.doesNotImply(BNDeltaTwo)))
menagerie.setProperty(BB2G, "hdim", 0, CompositeJustification(BB1G.hdim, BB2G.implies(BB1G)))
menagerie.addNonimplication(BB2G, ArrayComp, CompositeJustification(BB2G.category, ArrayComp.category))
menagerie.addNonimplication(BB2G, BN1G, CompositeJustification(BB2G.category, BN1G.category))
menagerie.addNonimplication(BB2G, BNW2G, CompositeJustification(BB2G.category, BNW2G.category))
menagerie.addNonimplication(BB2G, BOGL1, CompositeJustification(BB2G.category, BOGL1.category))
menagerie.addImplication(BB2R, BN3G, CompositeJustification(BB2R.implies(OmegaLow), OmegaLow.implies(BN3G)))
menagerie.addNonimplication(BB2R, BN1G, CompositeJustification(BB2R.measure, BN1G.measure))
menagerie.addNonimplication(BB2R, BN1R, CompositeJustification(BB2R.measure, BN1R.measure))
menagerie.addNonimplication(BB2R, BNLFO, CompositeJustification(BB2R.measure, BNLFO.measure))
menagerie.addNonimplication(BB2R, Low1Rand, CompositeJustification(Low1Rand.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB2R, LowSchnorr, CompositeJustification(LowSchnorr.implies(NotHigh), BB2R.doesNotImply(NotHigh)))
menagerie.addImplication(BB3R, BN2G, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(BN2G)))
menagerie.addImplication(BB3R, BNW2G, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(BNW2G)))
menagerie.addImplication(BB3R, BOGL2, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(BOGL2)))
menagerie.addNonimplication(BB3R, BB2G, CompositeJustification(BB3R.measure, BB2G.measure))
menagerie.addNonimplication(BB3R, BBmin, CompositeJustification(BB3R.measure, BBmin.measure))
menagerie.addNonimplication(BB3R, BIF, CompositeJustification(BB3R.measure, BIF.measure))
menagerie.addNonimplication(BB3R, BND1, CompositeJustification(BB3R.measure, BND1.measure))
menagerie.setProperty(BBmin, "category", 0, CompositeJustification(BN3G.category, BBmin.implies(BN3G)))
menagerie.addImplication(BIF, BN3G, CompositeJustification(BIF.implies(HIF), HIF.implies(BN3G)))
menagerie.addImplication(BIF, BOGL2, CompositeJustification(BIF.implies(HIF), HIF.implies(BOGL2)))
menagerie.addNonimplication(BIF, FSI, CompositeJustification(BIF.pdim, FSI.pdim))
menagerie.addNonimplication(BIF, SuperLow, CompositeJustification(BIF.cardinality, SuperLow.cardinality))
menagerie.setProperty(BND1, "category", 0, CompositeJustification(BN3G.category, BND1.implies(BN3G)))
menagerie.addNonimplication(BND1, FSI, CompositeJustification(FSI.implies(BOGL1), BND1.doesNotImply(BOGL1)))
menagerie.addNonimplication(BND1, LowSchnorr, CompositeJustification(BND1.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BND1, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), BND1.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1G, FSI, CompositeJustification(FSI.implies(BOGL1), BN1G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1G, LowSchnorr, CompositeJustification(BN1G.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BN1G, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), BN1G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1G, BND1, CompositeJustification(BND1.implies(NotPA), BN1G.doesNotImply(NotPA)))
menagerie.addNonimplication(BN2G, CET, CompositeJustification(BN2G.pdim, CET.pdim))
menagerie.addNonimplication(BN2G, BB1G, CompositeJustification(Low1Rand.implies(BN2G), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BN2G, BIF, CompositeJustification(LowKurtz.implies(BN2G), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(BN2G, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BN2G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2G, LowKurtz, CompositeJustification(LowKurtz.implies(NotAboveZP), BN2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2G, SuperLow, CompositeJustification(BOGL1.implies(BN2G), BOGL1.doesNotImply(SuperLow)))
menagerie.setProperty(BN3G, "cardinality", 1, CompositeJustification(JumpTraceable.cardinality, JumpTraceable.implies(BN3G)))
menagerie.setProperty(BN3G, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(BN3G)))
menagerie.addNonimplication(BN3G, CET, CompositeJustification(CET.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BB2G, CompositeJustification(BB2G.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, BIF, CompositeJustification(BIF.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BN1R, CompositeJustification(BN1R.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN3G, BN2R, CompositeJustification(BN2R.implies(NotPAinZP), BN3G.doesNotImply(NotPAinZP)))
menagerie.addNonimplication(BN3G, FSI, CompositeJustification(FSI.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, Low1Rand, CompositeJustification(Low1Rand.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, LowKurtz, CompositeJustification(LowKurtz.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, NotDNC, CompositeJustification(BBmin.implies(BN3G), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BN3G, NotDNCinZP, CompositeJustification(BBmin.implies(BN3G), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(BN3G, SuperLow, CompositeJustification(SuperLow.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BNHIF, CompositeJustification(BBmin.implies(BN3G), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN3G, BNmin, CompositeJustification(BBmin.implies(BN3G), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BN3G, BNSC, CompositeJustification(BND1.implies(BN3G), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BN3G, BB2R, CompositeJustification(BB2R.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN3G, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), BN3G.doesNotImply(NotAboveZP)))
menagerie.setProperty(BN1R, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BN1R)))
menagerie.addNonimplication(BN1R, BN1G, CompositeJustification(BN1G.implies(NotAED), BN1R.doesNotImply(NotAED)))
menagerie.addNonimplication(BN1R, FSI, CompositeJustification(FSI.implies(BOGL1), BN1R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN1R, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), BN1R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2R, ArrayComp, CompositeJustification(Low.implies(BN2R), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(BN2R, BB1G, CompositeJustification(BB1G.implies(BNSC), BN2R.doesNotImply(BNSC)))
menagerie.addNonimplication(BN2R, BB3R, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(BB3R)))
menagerie.addNonimplication(BN2R, BIF, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(BIF)))
menagerie.addNonimplication(BN2R, BN1G, CompositeJustification(BN1G.implies(NotAboveZP), BN2R.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2R, BN3G, CompositeJustification(BN2R.category, BN3G.category))
menagerie.addNonimplication(BN2R, BOGL2, CompositeJustification(BOGL2.implies(NotAboveZP), BN2R.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2R, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BN2R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2R, Low, CompositeJustification(Low.implies(BOGL1), BN2R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2R, LowKurtz, CompositeJustification(BNLFO.implies(BN2R), BNLFO.doesNotImply(LowKurtz)))
menagerie.addNonimplication(BN2R, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BN2R.doesNotImply(BNHIF)))
menagerie.addNonimplication(BN2R, BN1R, CompositeJustification(BN1R.implies(NotPA), BN2R.doesNotImply(NotPA)))
menagerie.addNonimplication(BNDeltaTwo, BB2R, CompositeJustification(BB2R.implies(BNmin), BNDeltaTwo.doesNotImply(BNmin)))
menagerie.addNonimplication(BNDeltaTwo, BND1, CompositeJustification(BND1.implies(NotPA), BNDeltaTwo.doesNotImply(NotPA)))
menagerie.addNonimplication(BNDeltaTwo, BN2G, CompositeJustification(BNDeltaTwo.category, BN2G.category))
menagerie.addNonimplication(BNDeltaTwo, BN2R, CompositeJustification(BNDeltaTwo.measure, BN2R.measure))
menagerie.addNonimplication(BNDeltaTwo, BOGL1, CompositeJustification(LowSchnorr.implies(BNDeltaTwo), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNDeltaTwo, BOGL2, CompositeJustification(BNDeltaTwo.category, BOGL2.category))
menagerie.addNonimplication(BNDeltaTwo, JumpTraceable, CompositeJustification(JumpTraceable.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, Low1Rand, CompositeJustification(Low1Rand.implies(NotPA), BNDeltaTwo.doesNotImply(NotPA)))
menagerie.addNonimplication(BNDeltaTwo, LowKurtz, CompositeJustification(LowKurtz.implies(NotHigh), BNDeltaTwo.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNDeltaTwo, LowSchnorr, CompositeJustification(LowSchnorr.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNDeltaTwo, NotDNC, CompositeJustification(NotDNC.implies(NotPA), BNDeltaTwo.doesNotImply(NotPA)))
menagerie.setProperty(BNHIF, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BNHIF)))
menagerie.addNonimplication(BNHIF, BB2G, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BB2G)))
menagerie.addNonimplication(BNHIF, BB2R, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BB2R)))
menagerie.addNonimplication(BNHIF, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), BNHIF.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, BBmin, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BBmin)))
menagerie.addNonimplication(BNHIF, BIF, CompositeJustification(OmegaLow.implies(BNHIF), OmegaLow.doesNotImply(BIF)))
menagerie.addNonimplication(BNHIF, BND1, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(BNHIF, BN2G, CompositeJustification(BNHIF.category, BN2G.category))
menagerie.addNonimplication(BNHIF, BOGL1, CompositeJustification(BOGL1.implies(NotAboveZP), BNHIF.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, HIF, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(HIF)))
menagerie.addNonimplication(BNHIF, Low, CompositeJustification(Low.implies(NotAboveZP), BNHIF.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, Low1Rand, CompositeJustification(Low1Rand.implies(NotAboveZP), BNHIF.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNHIF, NotDNC, CompositeJustification(OmegaLow.implies(BNHIF), OmegaLow.doesNotImply(NotDNC)))
menagerie.addNonimplication(BNHIF, SuperLow, CompositeJustification(Low.implies(BNHIF), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(BNLFO, BB1G, CompositeJustification(BNLFO.hdim, BB1G.hdim))
menagerie.addNonimplication(BNLFO, BND1, CompositeJustification(BND1.implies(NotPA), BNLFO.doesNotImply(NotPA)))
menagerie.addNonimplication(BNLFO, BN2G, CompositeJustification(BNLFO.category, BN2G.category))
menagerie.addNonimplication(BNLFO, BOGL1, CompositeJustification(LowSchnorr.implies(BNLFO), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNLFO, BOGL2, CompositeJustification(BNLFO.category, BOGL2.category))
menagerie.addNonimplication(BNLFO, Low1Rand, CompositeJustification(Low1Rand.implies(NotPA), BNLFO.doesNotImply(NotPA)))
menagerie.addNonimplication(BNLFO, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BNLFO.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNmin, BN2G, CompositeJustification(BNmin.category, BN2G.category))
menagerie.addNonimplication(BNmin, BN2R, CompositeJustification(BNmin.measure, BN2R.measure))
menagerie.addNonimplication(BNmin, BOGL2, CompositeJustification(BNmin.category, BOGL2.category))
menagerie.addNonimplication(BNmin, LowSchnorr, CompositeJustification(LowSchnorr.implies(BNDeltaTwo), BNmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNmin, SuperLow, CompositeJustification(SuperLow.implies(BNHIF), BNmin.doesNotImply(BNHIF)))
menagerie.setProperty(BNSC, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(BNSC)))
menagerie.addNonimplication(BNSC, BOGL1, CompositeJustification(LowSchnorr.implies(BNSC), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNSC, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), BNSC.doesNotImply(BNHIF)))
menagerie.addNonimplication(BNSC, SuperLow, CompositeJustification(SuperLow.implies(NotHigh), BNSC.doesNotImply(NotHigh)))
menagerie.addNonimplication(BNW2G, CET, CompositeJustification(BNW2G.pdim, CET.pdim))
menagerie.addNonimplication(BNW2G, BB1G, CompositeJustification(Low1Rand.implies(BNW2G), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BNW2G, BBmin, CompositeJustification(BIF.implies(BNW2G), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(BNW2G, BIF, CompositeJustification(LowKurtz.implies(BNW2G), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(BNW2G, BND1, CompositeJustification(BND1.implies(NotAboveZP), BNW2G.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BNW2G, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), BNW2G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNW2G, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), BNW2G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNW2G, Low, CompositeJustification(Low.implies(BOGL1), BNW2G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNW2G, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), BNW2G.doesNotImply(BNSC)))
menagerie.addNonimplication(BNW2G, LowKurtz, CompositeJustification(LowKurtz.implies(NotDNC), BNW2G.doesNotImply(NotDNC)))
menagerie.addNonimplication(BNW2G, SuperLow, CompositeJustification(Low.implies(BNW2G), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(BNW2G, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), BNW2G.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BNW2G, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), BNW2G.doesNotImply(NotAboveZP)))
menagerie.setProperty(BOGL1, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BOGL1)))
menagerie.addNonimplication(BOGL1, BIF, CompositeJustification(BIF.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, JumpTraceable, CompositeJustification(JumpTraceable.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, Low1Rand, CompositeJustification(Low1Rand.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, LowKurtz, CompositeJustification(LowKurtz.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, LowSchnorr, CompositeJustification(LowSchnorr.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(BOGL1, NotDNC, CompositeJustification(OmegaLow.implies(BOGL1), OmegaLow.doesNotImply(NotDNC)))
menagerie.addNonimplication(BOGL1, BB2R, CompositeJustification(BB2R.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.setProperty(BOGL2, "pdim", 1, CompositeJustification(BBmin.pdim, BBmin.implies(BOGL2)))
menagerie.addNonimplication(BOGL2, CET, CompositeJustification(CET.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BB1G, CompositeJustification(Low1Rand.implies(BOGL2), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BOGL2, BB2G, CompositeJustification(JumpTraceable.implies(BOGL2), JumpTraceable.doesNotImply(BB2G)))
menagerie.addNonimplication(BOGL2, BIF, CompositeJustification(BIF.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BN1R, CompositeJustification(OmegaLow.implies(BOGL2), OmegaLow.doesNotImply(BN1R)))
menagerie.addNonimplication(BOGL2, BNLFO, CompositeJustification(BBmin.implies(BOGL2), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(BOGL2, FSI, CompositeJustification(FSI.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, Low1Rand, CompositeJustification(Low1Rand.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, LowKurtz, CompositeJustification(LowKurtz.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, NotDNC, CompositeJustification(BBmin.implies(BOGL2), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(BOGL2, NotDNCinZP, CompositeJustification(BBmin.implies(BOGL2), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(BOGL2, SuperLow, CompositeJustification(SuperLow.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BNDeltaTwo, CompositeJustification(BBmin.implies(BOGL2), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(BOGL2, BNmin, CompositeJustification(BBmin.implies(BOGL2), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(BOGL2, BNSC, CompositeJustification(BND1.implies(BOGL2), BND1.doesNotImply(BNSC)))
menagerie.addNonimplication(BOGL2, BB2R, CompositeJustification(BB2R.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(BOGL2, BB3R, CompositeJustification(BB3R.implies(NotHigh), BOGL2.doesNotImply(NotHigh)))
menagerie.addNonimplication(DeltaTwo, BIF, CompositeJustification(BIF.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, JumpTraceable, CompositeJustification(Low.implies(DeltaTwo), Low.doesNotImply(JumpTraceable)))
menagerie.addNonimplication(DeltaTwo, LowKurtz, CompositeJustification(LowKurtz.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(DeltaTwo, LowSchnorr, CompositeJustification(Low.implies(DeltaTwo), Low.doesNotImply(LowSchnorr)))
menagerie.addNonimplication(DeltaTwo, BB1G, CompositeJustification(Low1Rand.implies(DeltaTwo), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(DeltaTwo, NotDNC, CompositeJustification(NotDNC.implies(NotAboveZP), DeltaTwo.doesNotImply(NotAboveZP)))
menagerie.addImplication(FSI, BN3G, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(BN3G)))
menagerie.addImplication(FSI, BNW2G, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(BNW2G)))
menagerie.addImplication(FSI, NotAboveZP, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(NotAboveZP)))
menagerie.addImplication(FSI, NotAED, CompositeJustification(FSI.implies(JumpTraceable), JumpTraceable.implies(NotAED)))
menagerie.addImplication(FSI, BN1R, CompositeJustification(FSI.implies(NotDNC), NotDNC.implies(BN1R)))
menagerie.addImplication(FSI, BNSC, CompositeJustification(FSI.implies(NotDNC), NotDNC.implies(BNSC)))
menagerie.addImplication(FSI, NotDNCinZP, CompositeJustification(FSI.implies(NotDNC), NotDNC.implies(NotDNCinZP)))
menagerie.addNonimplication(FSI, SuperLow, CompositeJustification(FSI.cardinality, SuperLow.cardinality))
menagerie.addNonimplication(FSI, BB3R, CompositeJustification(BB3R.implies(BNHIF), FSI.doesNotImply(BNHIF)))
menagerie.addNonimplication(FSI, BIF, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(BIF)))
menagerie.addNonimplication(FSI, LowKurtz, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(LowKurtz)))
menagerie.setProperty(HIF, "category", 0, CompositeJustification(BN1G.category, HIF.implies(BN1G)))
menagerie.addNonimplication(HIF, JumpTraceable, CompositeJustification(HIF.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(HIF, Low, CompositeJustification(HIF.cardinality, Low.cardinality))
menagerie.addNonimplication(HIF, LowSchnorr, CompositeJustification(HIF.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(HIF, BB3R, CompositeJustification(BB3R.implies(BNmin), HIF.doesNotImply(BNmin)))
menagerie.addNonimplication(HIF, BB1G, CompositeJustification(BB1G.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.addNonimplication(HIF, LowKurtz, CompositeJustification(LowKurtz.implies(NotPA), HIF.doesNotImply(NotPA)))
menagerie.addImplication(JumpTraceable, NotPAinZP, CompositeJustification(JumpTraceable.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addImplication(JumpTraceable, BN2R, CompositeJustification(JumpTraceable.implies(NotDNC), NotDNC.implies(BN2R)))
menagerie.addImplication(JumpTraceable, NotPA, CompositeJustification(JumpTraceable.implies(NotDNC), NotDNC.implies(NotPA)))
menagerie.addNonimplication(JumpTraceable, LowSchnorr, CompositeJustification(LowSchnorr.implies(NotHigh), JumpTraceable.doesNotImply(NotHigh)))
menagerie.addNonimplication(Low, BB3R, CompositeJustification(BB3R.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, BIF, CompositeJustification(BIF.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, FSI, CompositeJustification(FSI.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, LowKurtz, CompositeJustification(LowKurtz.implies(ArrayComp), Low.doesNotImply(ArrayComp)))
menagerie.addNonimplication(Low, BB2G, CompositeJustification(Low1Rand.implies(Low), Low1Rand.doesNotImply(BB2G)))
menagerie.addNonimplication(Low, NotDNC, CompositeJustification(SuperLow.implies(Low), SuperLow.doesNotImply(NotDNC)))
menagerie.setProperty(Low1Rand, "cardinality", 0, CompositeJustification(DeltaTwo.cardinality, Low1Rand.implies(DeltaTwo)))
menagerie.addImplication(Low1Rand, BN3G, CompositeJustification(Low1Rand.implies(JumpTraceable), JumpTraceable.implies(BN3G)))
menagerie.addImplication(Low1Rand, BN1R, CompositeJustification(Low1Rand.implies(NotDNC), NotDNC.implies(BN1R)))
menagerie.addImplication(Low1Rand, NotDNCinZP, CompositeJustification(Low1Rand.implies(NotDNC), NotDNC.implies(NotDNCinZP)))
menagerie.addNonimplication(Low1Rand, LowSchnorr, CompositeJustification(LowSchnorr.implies(BN1G), Low1Rand.doesNotImply(BN1G)))
menagerie.addImplication(LowKurtz, BOGL2, CompositeJustification(LowKurtz.implies(BN1G), BN1G.implies(BOGL2)))
menagerie.addImplication(LowKurtz, BN3G, CompositeJustification(LowKurtz.implies(BN2G), BN2G.implies(BN3G)))
menagerie.addImplication(LowKurtz, NotPAinZP, CompositeJustification(LowKurtz.implies(BN2R), BN2R.implies(NotPAinZP)))
menagerie.addNonimplication(LowKurtz, FSI, CompositeJustification(LowKurtz.pdim, FSI.pdim))
menagerie.addNonimplication(LowKurtz, Low1Rand, CompositeJustification(LowKurtz.pdim, Low1Rand.pdim))
menagerie.addNonimplication(LowKurtz, SuperLow, CompositeJustification(LowSchnorr.implies(LowKurtz), LowSchnorr.doesNotImply(SuperLow)))
menagerie.addNonimplication(LowKurtz, BB3R, CompositeJustification(BB3R.implies(BNmin), LowKurtz.doesNotImply(BNmin)))
menagerie.addImplication(LowSchnorr, BN2G, CompositeJustification(LowSchnorr.implies(BNW2G), BNW2G.implies(BN2G)))
menagerie.addImplication(LowSchnorr, BN3G, CompositeJustification(LowSchnorr.implies(BOGL2), BOGL2.implies(BN3G)))
menagerie.addImplication(LowSchnorr, NotAboveZP, CompositeJustification(LowSchnorr.implies(BOGL2), BOGL2.implies(NotAboveZP)))
menagerie.addImplication(LowSchnorr, BN2R, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(BN2R)))
menagerie.addImplication(LowSchnorr, NotPA, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(NotPA)))
menagerie.addNonimplication(NotAboveZP, BB3R, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(BB3R)))
menagerie.addNonimplication(NotAboveZP, BBmin, CompositeJustification(BIF.implies(NotAboveZP), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(NotAboveZP, BIF, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(BIF)))
menagerie.addNonimplication(NotAboveZP, BND1, CompositeJustification(BOGL2.implies(NotAboveZP), BOGL2.doesNotImply(BND1)))
menagerie.addNonimplication(NotAboveZP, BN3G, CompositeJustification(NotAboveZP.category, BN3G.category))
menagerie.addNonimplication(NotAboveZP, BN2R, CompositeJustification(NotAboveZP.measure, BN2R.measure))
menagerie.addNonimplication(NotAboveZP, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), NotAboveZP.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotAboveZP, Low, CompositeJustification(Low.implies(BOGL1), NotAboveZP.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotAboveZP, Low1Rand, CompositeJustification(Low1Rand.implies(BNSC), NotAboveZP.doesNotImply(BNSC)))
menagerie.addNonimplication(NotAboveZP, LowKurtz, CompositeJustification(BNLFO.implies(NotAboveZP), BNLFO.doesNotImply(LowKurtz)))
menagerie.addNonimplication(NotAboveZP, OmegaLow, CompositeJustification(OmegaLow.implies(BNHIF), NotAboveZP.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotAboveZP, SuperLow, CompositeJustification(Low.implies(NotAboveZP), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(NotDNC, BND1, CompositeJustification(BND1.implies(NotAED), NotDNC.doesNotImply(NotAED)))
menagerie.addNonimplication(NotDNC, BN3G, CompositeJustification(NotDNC.category, BN3G.category))
menagerie.addNonimplication(NotDNC, JumpTraceable, CompositeJustification(NotDNC.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(NotDNC, Low1Rand, CompositeJustification(Low1Rand.implies(BNHIF), NotDNC.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotDNC, LowKurtz, CompositeJustification(LowKurtz.implies(BNDeltaTwo), NotDNC.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNC, LowSchnorr, CompositeJustification(NotDNC.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(NotDNC, BB1G, CompositeJustification(Low1Rand.implies(NotDNC), Low1Rand.doesNotImply(BB1G)))
menagerie.setProperty(NotDNCinZP, "category", 1, CompositeJustification(BB2G.category, BB2G.implies(NotDNCinZP)))
menagerie.addNonimplication(NotDNCinZP, CET, CompositeJustification(NotDNCinZP.pdim, CET.pdim))
menagerie.addNonimplication(NotDNCinZP, BB2R, CompositeJustification(BB2R.implies(BNDeltaTwo), NotDNCinZP.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNCinZP, BB3R, CompositeJustification(BB3R.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, BND1, CompositeJustification(BND1.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, BOGL1, CompositeJustification(LowSchnorr.implies(NotDNCinZP), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotDNCinZP, DeltaTwo, CompositeJustification(NotDNCinZP.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(NotDNCinZP, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), NotDNCinZP.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNCinZP, Low, CompositeJustification(Low.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, Low1Rand, CompositeJustification(Low1Rand.implies(NotAboveZP), NotDNCinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotDNCinZP, SuperLow, CompositeJustification(Low.implies(NotDNCinZP), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(NotDNCinZP, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), NotDNCinZP.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNCinZP, NotDNC, CompositeJustification(NotDNC.implies(NotPA), NotDNCinZP.doesNotImply(NotPA)))
menagerie.addNonimplication(NotHigh, BB1G, CompositeJustification(Low1Rand.implies(NotHigh), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(NotHigh, BB2G, CompositeJustification(BB2G.implies(BNHIF), NotHigh.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotHigh, BB2R, CompositeJustification(BB2R.implies(BNmin), NotHigh.doesNotImply(BNmin)))
menagerie.addNonimplication(NotHigh, BND1, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(BND1)))
menagerie.addNonimplication(NotHigh, BN2G, CompositeJustification(NotHigh.category, BN2G.category))
menagerie.addNonimplication(NotHigh, BNLFO, CompositeJustification(NotHigh.measure, BNLFO.measure))
menagerie.addNonimplication(NotHigh, BOGL1, CompositeJustification(LowSchnorr.implies(NotHigh), LowSchnorr.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotHigh, BOGL2, CompositeJustification(NotHigh.category, BOGL2.category))
menagerie.addNonimplication(NotHigh, HIF, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(HIF)))
menagerie.addNonimplication(NotHigh, JumpTraceable, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(JumpTraceable)))
menagerie.addNonimplication(NotHigh, Low1Rand, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(Low1Rand)))
menagerie.addNonimplication(NotHigh, LowSchnorr, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(LowSchnorr)))
menagerie.addNonimplication(NotHigh, NotDNC, CompositeJustification(NotDNC.implies(NotPA), NotHigh.doesNotImply(NotPA)))
menagerie.addNonimplication(NotHigh, BNDeltaTwo, CompositeJustification(Low1Rand.implies(NotHigh), Low1Rand.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotPA, ArrayComp, CompositeJustification(ArrayComp.implies(NotAED), NotPA.doesNotImply(NotAED)))
menagerie.addNonimplication(NotPA, BB3R, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(BB3R)))
menagerie.addNonimplication(NotPA, BIF, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(BIF)))
menagerie.addNonimplication(NotPA, BND1, CompositeJustification(Low1Rand.implies(NotPA), Low1Rand.doesNotImply(BND1)))
menagerie.addNonimplication(NotPA, BN3G, CompositeJustification(NotPA.category, BN3G.category))
menagerie.addNonimplication(NotPA, BN1R, CompositeJustification(NotPA.measure, BN1R.measure))
menagerie.addNonimplication(NotPA, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), NotPA.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotPA, Low, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(Low)))
menagerie.addNonimplication(NotPA, LowKurtz, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(LowKurtz)))
menagerie.setProperty(NotPAinZP, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(NotPAinZP)))
menagerie.addNonimplication(NotPAinZP, CET, CompositeJustification(CET.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BB1G, CompositeJustification(BB1G.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, BN3G, CompositeJustification(NotPAinZP.category, BN3G.category))
menagerie.addNonimplication(NotPAinZP, BNW2G, CompositeJustification(BOGL1.implies(NotPAinZP), BOGL1.doesNotImply(BNW2G)))
menagerie.addNonimplication(NotPAinZP, JumpTraceable, CompositeJustification(JumpTraceable.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, LowKurtz, CompositeJustification(LowKurtz.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(NotPAinZP, SuperLow, CompositeJustification(SuperLow.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, BNHIF, CompositeJustification(BBmin.implies(NotPAinZP), BBmin.doesNotImply(BNHIF)))
menagerie.setProperty(OmegaLow, "category", 0, CompositeJustification(ArrayComp.category, OmegaLow.implies(ArrayComp)))
menagerie.addNonimplication(OmegaLow, CET, CompositeJustification(CET.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(OmegaLow, BN2R, CompositeJustification(OmegaLow.measure, BN2R.measure))
menagerie.addNonimplication(OmegaLow, LowKurtz, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(LowKurtz)))
menagerie.addNonimplication(OmegaLow, SuperLow, CompositeJustification(SuperLow.implies(NotHigh), OmegaLow.doesNotImply(NotHigh)))
menagerie.addImplication(SuperLow, NotPAinZP, CompositeJustification(SuperLow.implies(Low), Low.implies(NotPAinZP)))
menagerie.addImplication(SuperLow, BN2R, CompositeJustification(SuperLow.implies(NotDNCinZP), NotDNCinZP.implies(BN2R)))
menagerie.addNonimplication(SuperLow, LowKurtz, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(LowKurtz)))
menagerie.addNonimplication(SuperLow, CET, CompositeJustification(CET.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.addNonimplication(NotAED, CET, CompositeJustification(Low.implies(NotAED), Low.doesNotImply(CET)))
menagerie.addNonimplication(NotAED, BB1G, CompositeJustification(Low1Rand.implies(NotAED), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(NotAED, BB2R, CompositeJustification(SuperLow.implies(NotAED), SuperLow.doesNotImply(BB2R)))
menagerie.addNonimplication(NotAED, BBmin, CompositeJustification(BIF.implies(NotAED), BIF.doesNotImply(BBmin)))
menagerie.addNonimplication(NotAED, BIF, CompositeJustification(LowKurtz.implies(NotAED), LowKurtz.doesNotImply(BIF)))
menagerie.addNonimplication(NotAED, BN1G, CompositeJustification(Low.implies(NotAED), Low.doesNotImply(BN1G)))
menagerie.addNonimplication(NotAED, BN3G, CompositeJustification(NotAED.category, BN3G.category))
menagerie.addNonimplication(NotAED, BN1R, CompositeJustification(BN1R.implies(NotPA), NotAED.doesNotImply(NotPA)))
menagerie.addNonimplication(NotAED, BN2R, CompositeJustification(NotAED.measure, BN2R.measure))
menagerie.addNonimplication(NotAED, BNLFO, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(BNLFO)))
menagerie.addNonimplication(NotAED, BOGL1, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotAED, Low1Rand, CompositeJustification(SuperLow.implies(NotAED), SuperLow.doesNotImply(Low1Rand)))
menagerie.addNonimplication(NotAED, NotDNC, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(NotDNC)))
menagerie.addNonimplication(NotAED, NotDNCinZP, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(NotDNCinZP)))
menagerie.addNonimplication(NotAED, SuperLow, CompositeJustification(Low.implies(NotAED), Low.doesNotImply(SuperLow)))
menagerie.addNonimplication(NotAED, NotHigh, CompositeJustification(BB2R.implies(NotAED), BB2R.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotAED, BNDeltaTwo, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotAED, BNHIF, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(BNHIF)))
menagerie.addNonimplication(NotAED, BNmin, CompositeJustification(BBmin.implies(NotAED), BBmin.doesNotImply(BNmin)))
menagerie.addNonimplication(NotAED, BNSC, CompositeJustification(BND1.implies(NotAED), BND1.doesNotImply(BNSC)))
menagerie.setProperty(ArrayComp, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(ArrayComp)))
menagerie.addNonimplication(BB1G, JumpTraceable, CompositeJustification(BB1G.category, JumpTraceable.category))
menagerie.addNonimplication(BB2G, FSI, CompositeJustification(BB2G.category, FSI.category))
menagerie.addNonimplication(BB2G, Low1Rand, CompositeJustification(BB2G.category, Low1Rand.category))
menagerie.addNonimplication(BB2G, SuperLow, CompositeJustification(BB2G.cardinality, SuperLow.cardinality))
menagerie.addNonimplication(BB2R, JumpTraceable, CompositeJustification(BB2R.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(BB2R, NotDNC, CompositeJustification(BB2R.hdim, NotDNC.hdim))
menagerie.addNonimplication(BB3R, BB1G, CompositeJustification(BB3R.hdim, BB1G.hdim))
menagerie.addNonimplication(BB3R, FSI, CompositeJustification(BB3R.pdim, FSI.pdim))
menagerie.addNonimplication(BB3R, Low1Rand, CompositeJustification(BB3R.pdim, Low1Rand.pdim))
menagerie.addNonimplication(BB3R, LowKurtz, CompositeJustification(BB3R.hdim, LowKurtz.hdim))
menagerie.addNonimplication(BB3R, SuperLow, CompositeJustification(BB3R.cardinality, SuperLow.cardinality))
menagerie.addNonimplication(BN2R, LowSchnorr, CompositeJustification(BN2R.hdim, LowSchnorr.hdim))
menagerie.addNonimplication(BNDeltaTwo, NotDNCinZP, CompositeJustification(BNDeltaTwo.hdim, NotDNCinZP.hdim))
menagerie.setProperty(BNHIF, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BNHIF)))
menagerie.addNonimplication(BNHIF, JumpTraceable, CompositeJustification(BNHIF.category, JumpTraceable.category))
menagerie.addNonimplication(BNHIF, LowSchnorr, CompositeJustification(BNHIF.category, LowSchnorr.category))
menagerie.addNonimplication(BNLFO, FSI, CompositeJustification(BNLFO.hdim, FSI.hdim))
menagerie.addNonimplication(BNLFO, SuperLow, CompositeJustification(BNLFO.cardinality, SuperLow.cardinality))
menagerie.addNonimplication(BNmin, JumpTraceable, CompositeJustification(BNmin.category, JumpTraceable.category))
menagerie.addNonimplication(BNmin, NotDNCinZP, CompositeJustification(BNmin.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(BNSC, FSI, CompositeJustification(BNSC.pdim, FSI.pdim))
menagerie.addNonimplication(BNSC, Low1Rand, CompositeJustification(BNSC.pdim, Low1Rand.pdim))
menagerie.setProperty(BOGL1, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BOGL1)))
menagerie.setProperty(BOGL1, "pdim", 1, CompositeJustification(BB3R.pdim, BB3R.implies(BOGL1)))
menagerie.addNonimplication(NotAboveZP, LowSchnorr, CompositeJustification(NotAboveZP.hdim, LowSchnorr.hdim))
menagerie.addNonimplication(NotHigh, Low, CompositeJustification(NotHigh.cardinality, Low.cardinality))
menagerie.addNonimplication(NotPA, LowSchnorr, CompositeJustification(NotPA.hdim, LowSchnorr.hdim))
menagerie.addNonimplication(OmegaLow, DeltaTwo, CompositeJustification(OmegaLow.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(OmegaLow, NotDNCinZP, CompositeJustification(OmegaLow.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(NotAED, DeltaTwo, CompositeJustification(NotAED.cardinality, DeltaTwo.cardinality))
menagerie.addNonimplication(ArrayComp, BN2R, CompositeJustification(ArrayComp.measure, BN2R.measure))
menagerie.addNonimplication(ArrayComp, FSI, CompositeJustification(FSI.implies(BOGL1), ArrayComp.doesNotImply(BOGL1)))
menagerie.addNonimplication(ArrayComp, LowSchnorr, CompositeJustification(ArrayComp.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(ArrayComp, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), ArrayComp.doesNotImply(BOGL1)))
menagerie.addNonimplication(CET, LowSchnorr, CompositeJustification(LowSchnorr.implies(NotHigh), CET.doesNotImply(NotHigh)))
menagerie.addNonimplication(BB1G, ArrayComp, CompositeJustification(BB1G.category, ArrayComp.category))
menagerie.addNonimplication(BB1G, BN1G, CompositeJustification(BB1G.category, BN1G.category))
menagerie.addNonimplication(BB1G, BNW2G, CompositeJustification(BB1G.category, BNW2G.category))
menagerie.addNonimplication(BB1G, BOGL1, CompositeJustification(BB1G.category, BOGL1.category))
menagerie.addNonimplication(BB2G, BBmin, CompositeJustification(BB2G.category, BBmin.category))
menagerie.addNonimplication(BB2G, BND1, CompositeJustification(BB2G.category, BND1.category))
menagerie.addNonimplication(BB2G, HIF, CompositeJustification(BB2G.category, HIF.category))
menagerie.addNonimplication(BB2G, OmegaLow, CompositeJustification(BB2G.category, OmegaLow.category))
menagerie.setProperty(BB2R, "category", 0, CompositeJustification(ArrayComp.category, BB2R.implies(ArrayComp)))
menagerie.addNonimplication(BB2R, BBmin, CompositeJustification(BB2R.measure, BBmin.measure))
menagerie.addNonimplication(BB2R, BND1, CompositeJustification(BB2R.measure, BND1.measure))
menagerie.addImplication(BB3R, BN3G, CompositeJustification(BB3R.implies(OmegaLow), OmegaLow.implies(BN3G)))
menagerie.setProperty(BIF, "category", 0, CompositeJustification(BN3G.category, BIF.implies(BN3G)))
menagerie.setProperty(BN2G, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BN2G)))
menagerie.addNonimplication(BN2G, FSI, CompositeJustification(FSI.implies(BOGL1), BN2G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2G, LowSchnorr, CompositeJustification(BN2G.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BN3G, BB1G, CompositeJustification(Low1Rand.implies(BN3G), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(BN3G, LowSchnorr, CompositeJustification(LowSchnorr.implies(BN2G), BN3G.doesNotImply(BN2G)))
menagerie.addNonimplication(BN1R, BND1, CompositeJustification(BND1.implies(NotAED), BN1R.doesNotImply(NotAED)))
menagerie.addNonimplication(BN1R, BN3G, CompositeJustification(BN1R.category, BN3G.category))
menagerie.addNonimplication(BN2R, BND1, CompositeJustification(BND1.implies(NotAboveZP), BN2R.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(BN2R, BN2G, CompositeJustification(BN2R.category, BN2G.category))
menagerie.addNonimplication(BN2R, FSI, CompositeJustification(FSI.implies(BOGL1), BN2R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BN2R, SuperLow, CompositeJustification(SuperLow.implies(BOGL1), BN2R.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNDeltaTwo, BB1G, CompositeJustification(BB1G.implies(NotPA), BNDeltaTwo.doesNotImply(NotPA)))
menagerie.addNonimplication(BNDeltaTwo, BNLFO, CompositeJustification(BNDeltaTwo.measure, BNLFO.measure))
menagerie.addNonimplication(BNDeltaTwo, BNW2G, CompositeJustification(BNDeltaTwo.category, BNW2G.category))
menagerie.addNonimplication(BNDeltaTwo, FSI, CompositeJustification(FSI.implies(NotAED), BNDeltaTwo.doesNotImply(NotAED)))
menagerie.addNonimplication(BNHIF, BN2R, CompositeJustification(BNHIF.measure, BN2R.measure))
menagerie.addNonimplication(BNHIF, BNW2G, CompositeJustification(BNHIF.category, BNW2G.category))
menagerie.addNonimplication(BNHIF, LowKurtz, CompositeJustification(Low1Rand.implies(BNHIF), Low1Rand.doesNotImply(LowKurtz)))
menagerie.addNonimplication(BNLFO, ArrayComp, CompositeJustification(BNLFO.category, ArrayComp.category))
menagerie.addNonimplication(BNLFO, BN1G, CompositeJustification(BNLFO.category, BN1G.category))
menagerie.addNonimplication(BNLFO, BNW2G, CompositeJustification(BNLFO.category, BNW2G.category))
menagerie.addNonimplication(BNmin, ArrayComp, CompositeJustification(BNmin.category, ArrayComp.category))
menagerie.addNonimplication(BNmin, BN1G, CompositeJustification(BNmin.category, BN1G.category))
menagerie.addNonimplication(BNmin, BN1R, CompositeJustification(BNmin.measure, BN1R.measure))
menagerie.addNonimplication(BNmin, BNLFO, CompositeJustification(BNmin.measure, BNLFO.measure))
menagerie.addNonimplication(BNmin, BNW2G, CompositeJustification(BNmin.category, BNW2G.category))
menagerie.addNonimplication(BNmin, BOGL1, CompositeJustification(BNmin.category, BOGL1.category))
menagerie.addNonimplication(BNSC, BN3G, CompositeJustification(BNSC.category, BN3G.category))
menagerie.setProperty(BNW2G, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BNW2G)))
menagerie.addNonimplication(BNW2G, FSI, CompositeJustification(FSI.implies(BOGL1), BNW2G.doesNotImply(BOGL1)))
menagerie.addNonimplication(BNW2G, LowSchnorr, CompositeJustification(BNW2G.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(BOGL1, BN2R, CompositeJustification(BOGL1.measure, BN2R.measure))
menagerie.addNonimplication(BOGL1, FSI, CompositeJustification(FSI.implies(BNW2G), BOGL1.doesNotImply(BNW2G)))
menagerie.setProperty(BOGL2, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BOGL2)))
menagerie.addNonimplication(BOGL2, LowSchnorr, CompositeJustification(LowSchnorr.implies(BN2G), BOGL2.doesNotImply(BN2G)))
menagerie.addNonimplication(DeltaTwo, FSI, CompositeJustification(Low.implies(DeltaTwo), Low.doesNotImply(FSI)))
menagerie.addImplication(FSI, NotPAinZP, CompositeJustification(FSI.implies(NotAboveZP), NotAboveZP.implies(NotPAinZP)))
menagerie.addImplication(FSI, BN2R, CompositeJustification(FSI.implies(NotDNC), NotDNC.implies(BN2R)))
menagerie.addImplication(FSI, NotPA, CompositeJustification(FSI.implies(NotDNC), NotDNC.implies(NotPA)))
menagerie.addNonimplication(FSI, LowSchnorr, CompositeJustification(Low1Rand.implies(FSI), Low1Rand.doesNotImply(LowSchnorr)))
menagerie.addNonimplication(HIF, FSI, CompositeJustification(HIF.pdim, FSI.pdim))
menagerie.addNonimplication(HIF, SuperLow, CompositeJustification(HIF.cardinality, SuperLow.cardinality))
menagerie.addImplication(Low1Rand, BN2R, CompositeJustification(Low1Rand.implies(NotDNC), NotDNC.implies(BN2R)))
menagerie.setProperty(LowKurtz, "category", 0, CompositeJustification(HIF.category, LowKurtz.implies(HIF)))
menagerie.addImplication(LowSchnorr, NotPAinZP, CompositeJustification(LowSchnorr.implies(LowKurtz), LowKurtz.implies(NotPAinZP)))
menagerie.addNonimplication(NotAboveZP, BOGL2, CompositeJustification(NotAboveZP.category, BOGL2.category))
menagerie.addNonimplication(NotAboveZP, FSI, CompositeJustification(FSI.implies(BOGL1), NotAboveZP.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotDNC, BN2G, CompositeJustification(NotDNC.category, BN2G.category))
menagerie.addNonimplication(NotDNC, BOGL2, CompositeJustification(NotDNC.category, BOGL2.category))
menagerie.addNonimplication(NotDNC, FSI, CompositeJustification(NotDNC.pdim, FSI.pdim))
menagerie.addNonimplication(NotDNCinZP, BN3G, CompositeJustification(NotDNCinZP.category, BN3G.category))
menagerie.addNonimplication(NotDNCinZP, JumpTraceable, CompositeJustification(NotDNCinZP.pdim, JumpTraceable.pdim))
menagerie.addNonimplication(NotDNCinZP, LowKurtz, CompositeJustification(LowKurtz.implies(BNDeltaTwo), NotDNCinZP.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotDNCinZP, LowSchnorr, CompositeJustification(NotDNCinZP.pdim, LowSchnorr.pdim))
menagerie.addNonimplication(NotDNCinZP, BB1G, CompositeJustification(Low1Rand.implies(NotDNCinZP), Low1Rand.doesNotImply(BB1G)))
menagerie.addNonimplication(NotHigh, BB3R, CompositeJustification(BB3R.implies(BNmin), NotHigh.doesNotImply(BNmin)))
menagerie.addNonimplication(NotHigh, BNW2G, CompositeJustification(NotHigh.category, BNW2G.category))
menagerie.addNonimplication(NotHigh, FSI, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(FSI)))
menagerie.addNonimplication(NotHigh, LowKurtz, CompositeJustification(Low.implies(NotHigh), Low.doesNotImply(LowKurtz)))
menagerie.addNonimplication(NotPA, BN2G, CompositeJustification(NotPA.category, BN2G.category))
menagerie.addNonimplication(NotPA, BOGL2, CompositeJustification(NotPA.category, BOGL2.category))
menagerie.addNonimplication(NotPA, FSI, CompositeJustification(FSI.implies(BOGL1), NotPA.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotPA, SuperLow, CompositeJustification(BNmin.implies(NotPA), BNmin.doesNotImply(SuperLow)))
menagerie.addNonimplication(NotPAinZP, FSI, CompositeJustification(FSI.implies(NotAboveZP), NotPAinZP.doesNotImply(NotAboveZP)))
menagerie.addNonimplication(NotPAinZP, LowSchnorr, CompositeJustification(LowSchnorr.implies(BN2R), NotPAinZP.doesNotImply(BN2R)))
menagerie.addNonimplication(OmegaLow, JumpTraceable, CompositeJustification(JumpTraceable.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(OmegaLow, LowSchnorr, CompositeJustification(Low1Rand.implies(OmegaLow), Low1Rand.doesNotImply(LowSchnorr)))
menagerie.addNonimplication(SuperLow, LowSchnorr, CompositeJustification(Low1Rand.implies(SuperLow), Low1Rand.doesNotImply(LowSchnorr)))
menagerie.addNonimplication(SuperLow, JumpTraceable, CompositeJustification(JumpTraceable.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.addNonimplication(NotAED, BB2G, CompositeJustification(BB2G.implies(BNDeltaTwo), NotAED.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotAED, BB3R, CompositeJustification(BB3R.implies(NotHigh), NotAED.doesNotImply(NotHigh)))
menagerie.addNonimplication(NotAED, BND1, CompositeJustification(Low.implies(NotAED), Low.doesNotImply(BND1)))
menagerie.addNonimplication(NotAED, BN2G, CompositeJustification(NotAED.category, BN2G.category))
menagerie.addNonimplication(NotAED, BOGL2, CompositeJustification(NotAED.category, BOGL2.category))
menagerie.addNonimplication(NotAED, HIF, CompositeJustification(HIF.implies(BNDeltaTwo), NotAED.doesNotImply(BNDeltaTwo)))
menagerie.addNonimplication(NotAED, JumpTraceable, CompositeJustification(JumpTraceable.implies(BOGL1), NotAED.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotAED, Low, CompositeJustification(Low.implies(BOGL1), NotAED.doesNotImply(BOGL1)))
menagerie.addNonimplication(NotAED, LowKurtz, CompositeJustification(LowKurtz.implies(NotDNC), NotAED.doesNotImply(NotDNC)))
menagerie.addNonimplication(NotAED, LowSchnorr, CompositeJustification(Low.implies(NotAED), Low.doesNotImply(LowSchnorr)))
menagerie.addNonimplication(BB1G, FSI, CompositeJustification(BB1G.category, FSI.category))
menagerie.addNonimplication(BB2R, BB1G, CompositeJustification(BB2R.hdim, BB1G.hdim))
menagerie.addNonimplication(BB2R, FSI, CompositeJustification(BB2R.pdim, FSI.pdim))
menagerie.setProperty(BN2G, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BN2G)))
menagerie.addNonimplication(BNHIF, FSI, CompositeJustification(BNHIF.category, FSI.category))
menagerie.addNonimplication(BNHIF, NotDNCinZP, CompositeJustification(BNHIF.hdim, NotDNCinZP.hdim))
menagerie.addNonimplication(BNmin, FSI, CompositeJustification(BNmin.category, FSI.category))
menagerie.addNonimplication(BNmin, NotDNC, CompositeJustification(BNmin.hdim, NotDNC.hdim))
menagerie.setProperty(BNW2G, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BNW2G)))
menagerie.addNonimplication(BOGL1, NotDNCinZP, CompositeJustification(BOGL1.hdim, NotDNCinZP.hdim))
menagerie.setProperty(BOGL2, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BOGL2)))
menagerie.addNonimplication(BB1G, BBmin, CompositeJustification(BB1G.category, BBmin.category))
menagerie.addNonimplication(BB1G, BND1, CompositeJustification(BB1G.category, BND1.category))
menagerie.addNonimplication(BB2G, BB2R, CompositeJustification(BB2G.category, BB2R.category))
menagerie.addNonimplication(BB2G, BIF, CompositeJustification(BB2G.category, BIF.category))
menagerie.addNonimplication(BB2G, LowKurtz, CompositeJustification(BB2G.category, LowKurtz.category))
menagerie.setProperty(BB3R, "category", 0, CompositeJustification(BB2R.category, BB3R.implies(BB2R)))
menagerie.setProperty(BN3G, "measure", 1, CompositeJustification(BB3R.measure, BB3R.implies(BN3G)))
menagerie.addNonimplication(BN1R, BN2G, CompositeJustification(BN1R.category, BN2G.category))
menagerie.addNonimplication(BN1R, BOGL2, CompositeJustification(BN1R.category, BOGL2.category))
menagerie.addNonimplication(BN2R, BNW2G, CompositeJustification(BN2R.category, BNW2G.category))
menagerie.addNonimplication(BNmin, BBmin, CompositeJustification(BNmin.category, BBmin.category))
menagerie.addNonimplication(BNmin, BND1, CompositeJustification(BNmin.category, BND1.category))
menagerie.addNonimplication(BNSC, BN2G, CompositeJustification(BNSC.category, BN2G.category))
menagerie.addNonimplication(BNSC, BOGL2, CompositeJustification(BNSC.category, BOGL2.category))
menagerie.addNonimplication(BOGL2, BN2R, CompositeJustification(BOGL2.measure, BN2R.measure))
menagerie.addNonimplication(NotDNC, BNW2G, CompositeJustification(NotDNC.category, BNW2G.category))
menagerie.addNonimplication(NotDNCinZP, BN2G, CompositeJustification(NotDNCinZP.category, BN2G.category))
menagerie.addNonimplication(NotDNCinZP, FSI, CompositeJustification(NotDNCinZP.pdim, FSI.pdim))
menagerie.addNonimplication(NotPA, BNW2G, CompositeJustification(NotPA.category, BNW2G.category))
menagerie.addNonimplication(OmegaLow, FSI, CompositeJustification(FSI.implies(NotPA), OmegaLow.doesNotImply(NotPA)))
menagerie.addNonimplication(SuperLow, FSI, CompositeJustification(FSI.implies(NotPA), SuperLow.doesNotImply(NotPA)))
menagerie.addNonimplication(NotAED, BNW2G, CompositeJustification(NotAED.category, BNW2G.category))
menagerie.addNonimplication(NotAED, FSI, CompositeJustification(FSI.implies(BOGL1), NotAED.doesNotImply(BOGL1)))
menagerie.setProperty(BN3G, "hdim", 1, CompositeJustification(BB3R.hdim, BB3R.implies(BN3G)))
menagerie.addNonimplication(BNmin, BB1G, CompositeJustification(BNmin.hdim, BB1G.hdim))
menagerie.addNonimplication(BB2G, BB3R, CompositeJustification(BB2G.category, BB3R.category))
menagerie.addNonimplication(BN1R, BNW2G, CompositeJustification(BN1R.category, BNW2G.category))
menagerie.addNonimplication(BNSC, BNW2G, CompositeJustification(BNSC.category, BNW2G.category))
menagerie.addNonimplication(NotDNCinZP, BNW2G, CompositeJustification(NotDNCinZP.category, BNW2G.category))